fbb-7.0.11/ 0000775 0001750 0001750 00000000000 14136026521 007334 5 0000000 0000000 fbb-7.0.11/src/ 0000775 0001750 0001750 00000000000 14136026521 010123 5 0000000 0000000 fbb-7.0.11/src/mbl_read.c 0000664 0001750 0001750 00000043100 13613525371 011760 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
#include
/*
* Module MBL_READ.C
*/
#define NO_STATUS
static int mbl_rx (int);
static int read_mine (int);
static int teste_liste (bullist *);
/* Commande 'R' -> Read message */
/* Commande 'V' -> Read verbose message */
#include "aff_stat.c"
static int strfind (bullist * pbul, char *cherche)
{
return (strmatch (ltitre (1, pbul), cherche));
}
static int teste_liste (bullist * lbul)
{
if (lbul->numero < pvoie->recliste.debut)
return (0);
if (lbul->numero > pvoie->recliste.fin)
return (0);
if (lbul->date < pvoie->recliste.avant)
return (0);
if (lbul->date > pvoie->recliste.apres)
return (0);
if (!droits (COSYSOP))
{
if (strcmp (lbul->desti, "KILL") == 0)
return (0);
if (lbul->type == 'A')
return (0);
if ((lbul->status == 'K') && (pvoie->recliste.status != 'K'))
return (0);
if ((lbul->status == 'A') && (pvoie->recliste.status != 'A'))
return (0);
}
if (*pvoie->recliste.find)
return (strfind (lbul, pvoie->recliste.find));
if ((pvoie->recliste.type) && (pvoie->recliste.type != lbul->type))
return (0);
if ((pvoie->recliste.status) && (pvoie->recliste.status != lbul->status))
return (0);
if ((*pvoie->recliste.exp) && (!strmatch (lbul->exped, pvoie->recliste.exp)))
return (0);
if ((*pvoie->recliste.dest) && (!strmatch (lbul->desti, pvoie->recliste.dest)))
return (0);
if (*pvoie->recliste.bbs)
{
if (*pvoie->recliste.bbs == '-')
{
if (*lbul->bbsv)
return (0);
}
else
{
if (!strmatch (lbul->bbsv, pvoie->recliste.bbs))
return (0);
}
}
return (1);
}
static int read_mine (int mode)
{
/* Lecture des messages personnels */
bloc_mess *temp = tete_dir;
int i, nouveau = 0, trouve = 0;
unsigned indic;
bullist pbul;
mess_noeud *lptr;
char s[80];
rd_list *ptemp = NULL;
if (isdigit (mode))
{
s[0] = (char) mode;
s[1] = '\0';
insnoeud (s, &indic);
}
else
{
if (mode == 'N')
nouveau = 1;
indic = pvoie->no_indic;
}
ouvre_dir ();
while (temp->suiv)
temp = temp->suiv;
while (temp)
{
i = T_BLOC_MESS;
while (i--)
{
lptr = &temp->st_mess[i];
if ((lptr->noenr) && (lptr->no_indic == indic))
{
read_dir (lptr->noenr, &pbul);
if ((pbul.type) && (pbul.status != 'H') && ((!nouveau) || (nouveau && (pbul.status == 'N'))))
{
trouve = 1;
if (ptemp)
{
ptemp->suite = (rd_list *) m_alloue (sizeof (rd_list));
ptemp = ptemp->suite;
}
else
pvoie->t_read = ptemp = (rd_list *) m_alloue (sizeof (rd_list));
ptemp->suite = NULL;
ptemp->nmess = lptr->nmess;
ptemp->verb = pvoie->recliste.l;
}
}
}
temp = prec_dir (temp);
}
ferme_dir ();
if (!trouve)
{
if (nouveau)
texte (T_MBL + 4);
else
texte (T_MBL + 3);
}
return (trouve);
}
int mbl_bloc_list (void)
{
int retour = 0;
bullist ligne;
rd_list *ptemp;
unsigned offset = pvoie->recliste.offset;
bloc_mess *bptr = pvoie->recliste.ptemp;
mess_noeud *mptr;
ptemp = pvoie->t_read;
while (ptemp)
ptemp = ptemp->suite;
pvoie->seq = FALSE;
ouvre_dir ();
while (bptr)
{
--offset;
mptr = &(bptr->st_mess[offset]);
read_dir (mptr->noenr, &ligne);
if (ligne.numero < pvoie->recliste.debut)
break;
if ((mptr->noenr) && (droit_ok (&ligne, 1)) && (teste_liste (&ligne)))
{
if (pvoie->recliste.last-- == 0L)
break;
if (pvoie->temp1)
pvoie->temp1 = 0;
/* Entre le numero trouve en liste */
if (ptemp)
{
ptemp->suite = (rd_list *) m_alloue (sizeof (rd_list));
ptemp = ptemp->suite;
}
else
{
pvoie->t_read = ptemp = (rd_list *) m_alloue (sizeof (rd_list));
}
ptemp->suite = NULL;
ptemp->nmess = ligne.numero;
ptemp->verb = pvoie->recliste.l;
}
if (offset == 0)
{
bptr = prec_dir (bptr);
offset = T_BLOC_MESS;
}
if (!(POP (no_port (voiecur))) && (trait_time > MAXTACHE))
{
pvoie->seq = TRUE;
retour = 1;
break;
}
}
ferme_dir ();
pvoie->recliste.offset = offset;
pvoie->recliste.ptemp = bptr;
if ((!retour) && (pvoie->t_read))
retour = 2;
return (retour);
}
int mbl_rx (int verbose)
{
int error = 0;
long no;
int c, ok = TRUE;
bullist *pbul;
rd_list *ptemp = NULL;
df ("mbl_rx", 1);
/*
print_fonction(stdout); print_history(stdout); sleep_(10);
for (;;);
*/
sup_ln (indd);
c = toupper (*indd);
++indd;
if ((c != ' ') && (*indd != ' ') && (*indd != '\0'))
{
ff ();
return (1);
}
pvoie->aut_nc = 1;
libere_tread (voiecur);
init_recliste (voiecur);
pvoie->recliste.l = verbose;
switch (c)
{
case 'A':
pvoie->recliste.status = 'A';
break;
case 'B':
pvoie->recliste.type = 'B';
break;
case 'E':
if (droits (COSYSOP))
{
int v;
for (v = 0; v < NBVOIES; v++)
{
if ((svoie[v]->niv1 == N_MBL) && (svoie[v]->niv2 == 18))
{
texte (T_TRT + 0);
ok = 0; /* Interdit le multi-acces */
break;
}
}
if (ok)
{
maj_niv (N_MBL, 18, 0);
ff ();
return (review ());
}
}
else
{
--indd;
error = 1;
ok = 4;
}
break;
case 'F':
pvoie->recliste.status = 'F';
break;
case 'K':
pvoie->recliste.status = 'K';
break;
case 'L':
if (teste_espace ())
{
if (isdigit (*indd))
pvoie->recliste.last = lit_chiffre (0);
else
{
texte (T_ERR + 3);
ok = 0;
}
}
else
{
/* texte(T_ERR + 2) ; */
--indd;
error = 1;
ok = 4;
}
break;
case 'M':
case 'N':
if (read_mine (c))
ok = 2;
else
ok = 0;
break;
case 'P':
pvoie->recliste.type = 'P';
break;
case 'S':
if (teste_espace ())
strn_cpy (19, pvoie->recliste.find, indd);
else
{
/* texte(T_ERR + 2) ; */
--indd;
error = 1;
ok = 4;
}
break;
case 'T':
pvoie->recliste.type = 'T';
break;
case 'U':
pvoie->recliste.type = 'P';
pvoie->recliste.status = 'N';
break;
case 'X':
pvoie->recliste.status = 'X';
break;
case 'Y':
pvoie->recliste.status = 'Y';
break;
case '$':
pvoie->recliste.status = '$';
break;
case '<':
if (teste_espace ())
{
strn_cpy (6, pvoie->recliste.exp, indd);
}
else
{
texte (T_ERR + 2);
ok = 0;
}
break;
case '>':
if (teste_espace ())
{
strn_cpy (6, pvoie->recliste.dest, indd);
}
else
{
texte (T_ERR + 2);
ok = 0;
}
break;
case '@':
if (teste_espace ())
{
strn_cpy (6, pvoie->recliste.bbs, indd);
}
else
{
/* texte(T_ERR + 2) ; */
--indd;
error = 1;
ok = 4;
}
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
if (read_mine (c))
ok = 2;
else
ok = 0;
break;
case ' ':
if (strchr (indd, '-'))
{
if (isdigit (*indd))
pvoie->recliste.debut = lit_chiffre (1);
else
{
texte (T_ERR + 3);
ok = 0;
break;
}
++indd; /* saute le tiret */
if (isdigit (*indd))
pvoie->recliste.fin = lit_chiffre (1);
if (pvoie->recliste.fin <= pvoie->recliste.debut)
ok = 0;
}
else
{
ok = 0;
while ((no = lit_chiffre (1)) != 0L)
{
if ((pbul = ch_record (NULL, no, ' ')) != NULL)
{
if (droit_ok (pbul, 1))
{
if (ptemp)
{
ptemp->suite = (rd_list *) m_alloue (sizeof (rd_list));
ptemp = ptemp->suite;
}
else
{
pvoie->t_read = ptemp = (rd_list *) m_alloue (sizeof (rd_list));
}
ptemp->suite = NULL;
ptemp->nmess = no;
ptemp->verb = verbose;
ok = 2;
}
else
texte (T_ERR + 10);
}
else
texte (T_ERR + 10);
/* Only one message by request in POP mode */
if (POP (no_port (voiecur)))
break;
}
}
break;
default:
if ((c == '\0') && (verbose))
{
texte (T_MBL + 8);
ok = 0;
}
else
{
error = 1;
--indd;
ok = 4;
}
break;
}
switch (ok)
{
case 0:
retour_mbl ();
break;
case 1:
pvoie->recliste.ptemp = last_dir ();
pvoie->recliste.offset = T_BLOC_MESS;
pvoie->temp1 = 1;
pvoie->sr_mem = 1;
ch_niv3 (1);
mbl_read (verbose);
break;
case 2:
pvoie->sr_mem = 1;
ch_niv3 (2);
mbl_read (verbose);
break;
}
ff ();
return (error);
}
int mbl_read (int verbose)
{
int error = 0;
df ("mbl_read", 1);
switch (pvoie->niv3)
{
case 0:
error = mbl_rx (verbose);
break;
case 1:
switch (mbl_bloc_list ())
{
case 0: /* Pas de message */
texte (T_MBL + 3);
retour_mbl ();
case 1: /* Pas fini */
break;
case 2: /* Termine */
ch_niv3 (2);
mbl_read (verbose);
break;
}
break;
case 2:
if (mbl_mess_read () == 0)
{
retour_mbl ();
}
break;
case 3:
if (read_mess (1) == 0)
ch_niv3 (2);
break;
default:
fbb_error (ERR_NIVEAU, "MSG-READ", pvoie->niv3);
}
ff ();
return (error);
}
static void entete_mess (bullist * ligne)
{
*ptmes = *ligne;
if (*(ligne->bbsv))
sprintf (varx[0], "@%-6s ", ligne->bbsv);
else
*varx[0] = '\0';
texte (T_MBL + 35);
texte (T_MBL + 38);
}
static void end_read_mess (void)
{
char s[80];
rd_list *ptemp = pvoie->t_read;
if (ptemp)
{
sprintf (s, "R %ld", ptemp->nmess);
fbb_log (voiecur, 'M', s);
cr_cond ();
if (POP (no_port (voiecur)))
{
out("\033", 1);
}
else
{
texte (T_MBL + 33);
}
marque_obuf ();
pvoie->t_read = ptemp->suite;
m_libere (ptemp, sizeof (rd_list));
}
}
char *pop_date(long date)
{
char *day[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
char *mon[]= {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
struct tm *sdate;
static char cdate[40];
sdate = localtime (&date);
sprintf (cdate, "%s, %02d %s %d %02d:%02d:%02d %+03ld00",
day[sdate->tm_wday],
sdate->tm_mday,
mon[sdate->tm_mon],
sdate->tm_year %100 + 2000,
sdate->tm_hour,
sdate->tm_min,
sdate->tm_sec,
-timezone/3600);
return cdate;
}
int read_mess (int verbose)
{
int nb;
FILE *fptr;
char chaine[256];
rd_list *ptemp = pvoie->t_read;
nb = 0;
if ((fptr = ouvre_mess (O_TEXT, ptemp->nmess, '\0')) != NULL)
{
fseek (fptr, pvoie->enrcur, 0);
if (!verbose)
fseek (fptr, supp_header (fptr, 1), 0);
fflush (fptr);
while ((nb = read (fileno (fptr), chaine, 250)) > 0)
{
outs (chaine, nb);
if (!(POP (no_port (voiecur))) && (pvoie->memoc >= MAXMEM))
{
/* if (!getvoie(CONSOLE]->connect) cprintf("Max atteint\r\n") ; */
pvoie->enrcur = ftell (fptr);
break;
}
}
ferme (fptr, 45);
}
if (nb == 0)
end_read_mess ();
return (nb);
}
static void trans_header (char *ptr, char *bbsfrom, long date)
{
static char ligne[80];
int c;
int champ;
int nb;
int len;
int bbs;
char rbbs[80];
char home[41];
ptr += 2;
champ = 2;
nb = 0;
bbs = 0;
*home = '\0';
date = 0L;
do
{
c = *ptr;
switch (champ)
{
case 0:
switch (c)
{
case '@':
bbs = 1;
champ = 3;
nb = 0;
break;
case '#':
champ = 6;
nb = 0;
break;
case '$':
champ = 7;
nb = 0;
break;
case '[':
champ = 4;
nb = 0;
break;
case 'Z':
if (*(ptr + 1) == ':')
{
++ptr;
champ = 5;
nb = 0;
}
break;
default:
if ((bbs == 0) && (isdigit (c)))
{
nb = 0;
rbbs[nb++] = c;
champ = 6;
}
}
case 1:
if (isspace (c))
champ = 0;
break;
case 2: /* Lecture de la date - Mettre la date la plus ancienne */
if (nb <= 10)
rbbs[nb] = c;
if (nb == 10)
{
long rdate ;
rbbs[11] = '\0';
rbbs[6] = '\0';
if ((rdate = date_to_time (rbbs)) != 0L)
date = rdate + hour_to_time (rbbs + 7);
champ = 1;
}
++nb;
break;
case 3: /* Lecture du home BBS */
if ((nb == 0) && (c == ':'))
break;
if ((ISGRAPH (c)) && (nb < 40))
{
rbbs[nb++] = c;
}
else
{
rbbs[nb] = '\0';
strn_cpy (40, home, rbbs);
champ = 0;
}
break;
case 4: /* Lecture du Qth */
if ((c != ']') && (nb < 30))
{
rbbs[nb++] = c;
}
else
{
rbbs[nb] = '\0';
champ = 0;
}
break;
case 5: /* Lecture du Zip Code */
if ((ISGRAPH (c)) && (nb < 8))
{
rbbs[nb++] = c;
}
else
{
rbbs[nb] = '\0';
champ = 0;
}
break;
case 6: /* Lecture du home premier numero */
if ((nb == 0) && (c == ':'))
break;
if ((isdigit (c)) && (nb < 10))
{
rbbs[nb++] = c;
}
else
{
rbbs[nb] = '\0';
if ((bbs == 0) && (c == '@'))
{
bbs = 1;
champ = 3;
nb = 0;
}
else
champ = 0;
}
break;
case 7: /* Lecture du BID/MID */
if ((nb == 0) && (c == ':'))
break;
if ((ISGRAPH (c)) && (nb < 12))
{
rbbs[nb++] = c;
}
else
{
rbbs[nb] = '\0';
champ = 0;
}
break;
}
++ptr;
}
while (ISPRINT (c));
len = sprintf(ligne, "Received: from %s ; %s", home, pop_date(date));
outsln(ligne, len);
strcpy(bbsfrom, home);
}
static char *read_headers(long date)
{
int nb;
FILE *fptr;
char chaine[256];
rd_list *ptemp = pvoie->t_read;
static char bbs[41];
nb = 0;
*bbs = '\0';
if ((fptr = ouvre_mess (O_TEXT, ptemp->nmess, '\0')) != NULL)
{
while (fgets(chaine, sizeof(chaine), fptr))
{
if (strncmp("R:", chaine, 2) != 0)
break;
trans_header(chaine, bbs, date);
}
ferme (fptr, 45);
}
return bbs;
}
char *xuidl(long numero, char *callsign)
{
int i;
char call[10];
static char str[50];
sprintf(call, "%6s", callsign);
for (i = 0 ; i < 6 ; i++)
sprintf(str+i*2, "%02x", call[i] & 0xff);
sprintf(str+i*2, "%032lx", numero);
return str;
}
int mbl_mess_read (void)
{
bullist *pbul;
rd_list *ptemp;
while ((ptemp = pvoie->t_read) != NULL)
{
/* cprintf("Lit le %ld\r\n", ptemp->nmess) ; */
if ((pbul = ch_record (NULL, ptemp->nmess, 'Y')) != NULL)
{
if (POP (no_port (voiecur)))
{
int nb;
char chaine[80];
char name[80];
char exped[80];
char *reply;
Wps *wps;
/* Get the name from WP */
wps = wp_find(pbul->exped, 0);
if ((wps) && (*wps->name) && (*wps->name != '?'))
{
sprintf(name, "%s (%s)", pbul->exped, wps->name);
}
else
{
strcpy(name, pbul->exped);
}
/* Dump headers and get the older BBS for return address */
reply = read_headers(pbul->date);
if (*reply == '\0')
reply = mypath;
/**** SHOULD BE CONFIGURABLE (BEGIN) ****/
if (*pop_host)
{
/*** address like f6fbb%f6fbb.fmlr.fra.eu@f6fbb.ampr.org */
nb = snprintf(exped, sizeof(exped)-1, "%s%%%s@%s", pbul->exped, reply, pop_host);
exped[sizeof(exped)-1] = 0;
}
else
{
nb = snprintf(exped, sizeof(exped)-1, "%s@%s", pbul->exped, reply);
exped[sizeof(exped)-1] = 0;
}
/**** SHOULD BE CONFIGURABLE (END) ****/
nb = snprintf(chaine, sizeof(chaine), "Date: %s", pop_date(pbul->datesd));
outsln (chaine, nb);
nb = snprintf(chaine, sizeof(chaine), "From: %s <%s>", name, exped);
outsln (chaine, nb);
if (pbul->type == 'B')
{
/* News -- When user enters Reply, this is where reply goes. Thunderbird, at least, doesn't mind that these names don't match the group name, and it makes replies go to the correct distribution */
if (!pbul->bbsv[0])
{
nb = snprintf(chaine, sizeof(chaine)-1, "Newsgroups: %s", pbul->desti );
}
else
{
nb = snprintf(chaine, sizeof(chaine)-1, "Newsgroups: %s@%s", pbul->desti, pbul->bbsv );
}
outsln(chaine, nb);
nb = snprintf(chaine,sizeof(chaine), "Subject: %s", pbul->titre); // Removed [desti] to prevent Subjects from being changed during reply
outsln (chaine, nb);
nb = snprintf(chaine, sizeof(chaine), "Message-ID: <%s>", pbul->bid); /* Use BID for Message-ID. This allows messages to be downloaded even if they change groups. Reading will now ref bid */
outsln (chaine, nb);
}
else
{
/* To: Moved here. To: is not correct for */
nb = snprintf(chaine, sizeof(chaine), "To: %s", pbul->desti);
outsln (chaine, nb);
/* Mail */
nb = snprintf(chaine,sizeof(chaine), "Subject: %s", pbul->titre);
outsln (chaine, nb);
nb = snprintf(chaine, sizeof(chaine), "Message-ID: <%ld@%s>", pbul->numero, mycall);
outsln (chaine, nb);
nb = snprintf(chaine, sizeof(chaine), "X-UIDL: %s", xuidl(pbul->numero, mycall));
outsln (chaine, nb);
}
cr();
}
else
{
entete_mess (pbul);
}
pvoie->enrcur = 0L;
if (read_mess (ptemp->verb))
{
ch_niv3 (3);
return (1);
}
}
else
{
pvoie->t_read = ptemp->suite;
m_libere (ptemp, sizeof (rd_list));
}
}
return (0);
}
void libere_tread (int voie)
{
rd_list *ptemp = svoie[voie]->t_read;
rd_list *pprec;
while ((pprec = ptemp) != NULL)
{
ptemp = pprec->suite;
m_libere (pprec, sizeof (rd_list));
}
svoie[voie]->t_read = NULL;
}
void libere_tlist (int voie)
{
rd_list *ptemp = svoie[voie]->t_list;
rd_list *pprec;
while ((pprec = ptemp) != NULL)
{
ptemp = pprec->suite;
m_libere (pprec, sizeof (rd_list));
}
svoie[voie]->t_list = NULL;
}
fbb-7.0.11/src/statis.c 0000664 0001750 0001750 00000021163 13613525371 011527 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
/*
* MODULE STATIS.C
*/
#include
#ifdef THIRTYTWOBITDATA
static struct tm *fbb_localtime(int *time)
{
long ltime = *time;
return localtime(<ime);
}
#else
#define fbb_localtime localtime
#endif
static void menu_statistiques (void);
static void histo_jour (void)
{
FILE *fptr;
long hist[7], max, sommet, nbc, debtime;
int i, d;
struct tm *sdate;
statis buffstat;
for (i = 0; i < 7; hist[i++] = 0L)
;
incindd ();
tester_masque ();
debtime = time (NULL) - (86400L * 14L);
fptr = ouvre_stats ();
fflush (fptr);
nbc = filelength (fileno (fptr));
do
{
nbc -= (MAXSTAT * (long) sizeof (buffstat));
if (nbc < 0L)
{
nbc = 0;
break;
}
fseek (fptr, nbc, 0);
fread ((char *) &buffstat, sizeof (buffstat), 1, fptr);
}
while (buffstat.datcnx > debtime);
do
{
if (buffstat.datcnx >= debtime)
{
char cal[8];
n_cpy (6, cal, buffstat.indcnx);
if (strmatch (cal, pvoie->ch_temp))
{
sdate = fbb_localtime (&buffstat.datcnx);
hist[(sdate->tm_wday + 6) % 7] += buffstat.tpscnx;
}
}
}
while (fread ((char *) &buffstat, sizeof (buffstat), 1, fptr) == 1);
ferme (fptr, 13);
sommet = max = 10L;
for (i = 0; i < 7; i++)
if (hist[i] > max)
max = hist[i];
for (i = 0; i < 7; i++)
hist[i] = (hist[i] * sommet) / max;
texte (T_STA + 3);
for (i = (int) sommet; i > 0; i--)
{
out (" ", 1);
for (d = 0; d < 7; d++)
{
if (hist[d] >= i)
out (" *** ", 5);
else
out (" ", 5);
}
out ("\r", 1);
}
outln (" ----------------------------------", 35);
texte (T_STA + 4);
retour_menu (N_STAT);
}
static void histo_heure (void)
{
long hist[24], max, sommet;
FILE *fptr;
int i, h;
long nbc, nbc_total;
struct tm *sdate;
statis buffstat;
long record;
for (i = 0; i < 24; hist[i++] = 0L)
;
incindd ();
tester_masque ();
fptr = ouvre_stats ();
fflush (fptr);
record = filelength (fileno (fptr));
nbc_total = record / (long) sizeof (statis);
nbc = record - (MAXSTAT * (long) sizeof (statis));
if (nbc < 0L)
nbc = 0L;
fseek (fptr, nbc, 0);
if (record)
{
nbc = MAXSTAT;
}
else
{
nbc = nbc_total;
}
while (fread ((char *) &buffstat, sizeof (buffstat), 1, fptr) == 1)
{
char cal[8];
n_cpy (6, cal, buffstat.indcnx);
if (strmatch (cal, pvoie->ch_temp))
{
sdate = fbb_localtime (&buffstat.datcnx);
hist[sdate->tm_hour] += buffstat.tpscnx;
}
}
ferme (fptr, 14);
sommet = max = 10L;
for (i = 0; i < 24; i++)
if (hist[i] > max)
max = hist[i];
for (i = 0; i < 24; i++)
hist[i] = (hist[i] * sommet) / max;
texte (T_STA + 5);
for (i = (int) sommet; i > 0; i--)
{
for (h = 0; h < 24; h++)
{
if (hist[h] >= i)
out ("*", 1);
else
out (" ", 1);
}
out ("\r", 1);
}
outln ("------------------------", 24);
texte (T_STA + 6);
texte (T_STA + 7);
retour_menu (N_STAT);
}
static void generalites (void)
{
struct tm *sdate;
statis buffstat;
FILE *fptr;
long nbc = (long) MAXSTAT, nbc_total;
int i, nbjour = 0, h1 = 0, h2 = 0;
long hist[24], somme_tps = 0L, max1 = 0L, max2 = 0L;
long record, depart = 0;
for (i = 0; i < 24; hist[i++] = 0L)
;
fptr = ouvre_stats ();
fflush (fptr);
record = filelength (fileno (fptr));
nbc_total = record / (long) sizeof (statis);
nbc = record - (MAXSTAT * (long) sizeof (statis));
if (nbc < 0L)
nbc = 0L;
fseek (fptr, nbc, 0);
nbc = 0L;
nbjour = 0L;
while (fread ((char *) &buffstat, sizeof (buffstat), 1, fptr) == 1)
{
if (nbjour == 0)
{
/* Compte le nombre de jours */
nbjour = (int) ((time (NULL) - buffstat.datcnx) / 86400L);
/* Fait le calcul sur un nombre de jours entier */
depart = time (NULL) - (long) nbjour *86400L;
}
sdate = fbb_localtime (&buffstat.datcnx);
if (buffstat.datcnx > depart)
{
hist[sdate->tm_hour] += (long) buffstat.tpscnx;
++nbc;
}
}
for (i = 0; i < 24; i++)
{
somme_tps += hist[i];
if (hist[i] > max1)
{
h2 = h1;
max2 = max1;
h1 = i;
max1 = hist[i];
}
else if (hist[i] > max2)
{
h2 = i;
max2 = hist[i];
}
}
rewind (fptr);
fread ((char *) &buffstat, sizeof (buffstat), 1, fptr);
ferme (fptr, 15);
texte (T_STA + 8);
ltoa (nbc_total, varx[0], 10);
if (nbc_total)
ptmes->date = buffstat.datcnx;
else
ptmes->date = time (NULL);
texte (T_STA + 9);
if (nbc)
i = (int) (somme_tps / (long) nbc);
else
i = 0;
itoa (i / 60, varx[0], 10);
sprintf (varx[1], "%02d", i % 60);
texte (T_STA + 10);
if (nbjour == 0)
nbjour = 1;
ltoa (nbc / (long) nbjour, varx[0], 10);
texte (T_STA + 11);
itoa (h1, varx[0], 10);
itoa (h2, varx[1], 10);
texte (T_STA + 12);
retour_menu (N_STAT);
}
static void occupation (void)
{
long total, stotal;
float ftotal;
stotal = stemps[N_DOS] + stemps[N_QRA] + stemps[N_INFO] +
stemps[N_STAT] + stemps[N_NOMC] + stemps[N_TRAJ];
total = stotal + stemps[N_MBL];
ftotal = ((float) total) / 100.0;
if (ftotal == 0.0)
{
ftotal = 1E-5;
}
texte (T_STA + 13);
sprintf (varx[0], "%4.1f", ((float) stemps[N_MBL]) / ftotal);
texte (T_STA + 14);
sprintf (varx[0], "%4.1f", ((float) stotal) / ftotal);
texte (T_STA + 15);
ftotal = (float) (stotal) / 100.0;
if (ftotal == 0.0)
ftotal = 1E-5;
texte (T_STA + 16);
sprintf (varx[0], "%4.1f", ((float) stemps[N_DOS]) / ftotal);
texte (T_STA + 17);
sprintf (varx[0], "%4.1f", ((float) stemps[N_QRA]) / ftotal);
texte (T_STA + 18);
sprintf (varx[0], "%4.1f", ((float) stemps[N_INFO]) / ftotal);
texte (T_STA + 19);
sprintf (varx[0], "%4.1f", ((float) stemps[N_STAT]) / ftotal);
texte (T_STA + 20);
sprintf (varx[0], "%4.1f", ((float) stemps[N_NOMC]) / ftotal);
texte (T_STA + 21);
sprintf (varx[0], "%4.1f", ((float) stemps[N_TRAJ]) / ftotal);
texte (T_STA + 22);
retour_menu (N_STAT);
}
static void liste_connect (void)
{
char c;
FILE *fptr;
pvoie->lignes = -1;
switch (pvoie->niv3)
{
case 0:
incindd ();
tester_masque ();
fptr = ouvre_stats ();
fseek (fptr, 0L, 2);
pvoie->noenr_menu = ftell (fptr);
if (page_connect ('\0', fptr))
{
texte (T_TRT + 11);
maj_niv (3, 1, 1);
}
else
retour_menu (N_STAT);
ferme (fptr, 16);
break;
case 1:
c = toupper (*indd);
if ((c == 'A') || (c == 'F') || (c == Non))
{
maj_niv (3, 0, 0);
incindd ();
menu_statistiques ();
}
else
{
fptr = ouvre_stats ();
if (!page_connect ('\0', fptr))
retour_menu (N_STAT);
else
texte (T_TRT + 11);
ferme (fptr, 17);
}
break;
default:
fbb_error (ERR_NIVEAU, "LIST-CONN", pvoie->niv3);
break;
}
}
/*
* MENUS - PREMIER NIVEAU STATISTIQUES
*/
static void menu_statistiques (void)
{
int error = 0;
char com[80];
limite_commande ();
while (*indd && (!ISGRAPH (*indd)))
indd++;
strn_cpy (70, com, indd);
switch (toupper (*indd))
{
case 'L':
maj_niv (3, 1, 0);
liste_connect ();
break;
case 'I':
maj_niv (3, 2, 0);
incindd ();
liste_indic ();
break;
case 'J':
maj_niv (3, 3, 0); /* maj_niv non necessaire */
histo_jour (); /* histo traite en un seul bloc */
break;
case 'H':
maj_niv (3, 4, 0);
histo_heure ();
break;
case 'G':
maj_niv (3, 5, 0);
generalites ();
break;
case 'O':
maj_niv (3, 6, 0);
occupation ();
break;
case 'B':
maj_niv (N_MENU, 0, 0);
sortie ();
break;
case 'F':
maj_niv (0, 1, 0);
incindd ();
choix ();
break;
case '\0':
prompt (pvoie->finf.flags, pvoie->niv1);
break;
default:
if (!defaut ())
error = 1;
break;
}
if (error)
{
cmd_err (indd);
}
}
void statistiques (void)
{
switch (pvoie->niv2)
{
case 0:
menu_statistiques ();
break;
case 1:
liste_connect ();
break;
case 2:
liste_indic ();
break;
case 3:
histo_jour ();
break;
case 4:
histo_heure ();
break;
case 5:
generalites ();
break;
case 6:
occupation ();
break;
default:
fbb_error (ERR_NIVEAU, "STATS", pvoie->niv2);
break;
}
}
fbb-7.0.11/src/trajovl.c 0000664 0001750 0001750 00000025470 13613525371 011706 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
/*
* MODULE TRAJECTOGRAPHIE (OVELAY)
*/
#include
static void affiche_param (satel *);
static void ecrit_sat (satel *);
static void supprime_sat (void);
static void vis_param (satel *);
/*
* CARACTERISTIQUES SATELLITE
*/
void carac_satel (void)
{
int i;
FILE *fptr;
satel bufsat;
char satstr[80];
if ((i = selection_sat ()) == -1)
return;
fptr = ouvre_sat ();
pvoie->enrcur = (long) sizeof (bufsat) * (long) i;
fflush (fptr);
if (pvoie->enrcur < filelength (fileno (fptr)))
{
fseek (fptr, pvoie->enrcur, 0);
fread ((char *) &bufsat, sizeof (bufsat), 1, fptr);
sprintf (satstr, "SAT\\%ld.SAT", bufsat.cat);
if (!outfichs (d_disque (satstr)))
{
texte (T_TRJ + 12);
}
}
ferme (fptr, 25);
maj_niv (6, 0, 0);
prompt (pvoie->finf.flags, pvoie->niv1);
}
/*
* SAISIE PARAMETRES SATELLITE
*/
void modif_satel (void)
{
char c;
int i;
satel bufsat;
FILE *fptr;
switch (pvoie->niv3)
{
case 0:
if ((i = selection_sat ()) == -1)
break;
if (i < 0)
{
texte (T_ERR + 0);
menu_sat ();
}
else
{
fptr = ouvre_sat ();
pvoie->enrcur = (long) sizeof (bufsat) * (long) i;
fflush (fptr);
if (pvoie->enrcur < filelength (fileno (fptr)))
{
fseek (fptr, pvoie->enrcur, 0);
fread ((char *) &bufsat, sizeof (bufsat), 1, fptr);
vis_param (&bufsat);
ptmes->date = bufsat.maj;
pvoie->temp1 = 0;
texte (T_TRJ + 13);
var_cpy (0, bufsat.dd);
texte (T_MBL + 30);
}
else
{
fflush (fptr);
pvoie->enrcur = filelength (fileno (fptr));
pvoie->temp1 = 1;
texte (T_QST + 4);
}
maj_niv (6, 9, 2);
ferme (fptr, 25);
}
break;
case 2:
c = toupper (*indd);
if (pvoie->temp1)
{ /* Creation */
if (c == Oui)
{
texte (T_TRJ + 14);
maj_niv (6, 9, 3);
}
else if (c == Non)
{
maj_niv (6, 0, 0);
prompt (pvoie->finf.flags, pvoie->niv1);
}
else
{
texte (T_ERR + 0);
texte (T_QST + 4);
}
}
else
{ /* Suppression */
if (c == Non)
{
texte (T_TRJ + 14);
maj_niv (6, 9, 3);
}
else if (c == Oui)
{
/* Supprime le record */
supprime_sat ();
maj_niv (6, 0, 0);
prompt (pvoie->finf.flags, pvoie->niv1);
}
else
{
texte (T_ERR + 0);
texte (T_QST + 1);
}
}
break;
case 3:
lit_sat (&bufsat);
i = 0;
bufsat.maj = time (NULL);
if (ISPRINT (*indd))
{
while (ISGRAPH (*indd))
bufsat.dd[i++] = toupper (*indd++);
bufsat.dd[i] = '\0';
}
ecrit_sat (&bufsat);
texte (T_TRJ + 15);
maj_niv (6, 9, 4);
break;
case 4:
lit_sat (&bufsat);
if (ISGRAPH (*indd))
bufsat.k0 = atol (indd);
ecrit_sat (&bufsat);
texte (T_TRJ + 16);
maj_niv (6, 9, 5);
break;
case 5:
lit_sat (&bufsat);
if (ISGRAPH (*indd))
bufsat.y3 = atoi (indd);
ecrit_sat (&bufsat);
texte (T_TRJ + 17);
maj_niv (6, 9, 6);
break;
case 6:
lit_sat (&bufsat);
if (ISGRAPH (*indd))
bufsat.d3 = atof (indd);
ecrit_sat (&bufsat);
texte (T_TRJ + 18);
maj_niv (6, 9, 7);
break;
case 7:
lit_sat (&bufsat);
if (ISGRAPH (*indd))
bufsat.m0 = atof (indd);
ecrit_sat (&bufsat);
texte (T_TRJ + 19);
maj_niv (6, 9, 8);
break;
case 8:
lit_sat (&bufsat);
if (ISGRAPH (*indd))
bufsat.w0 = atof (indd);
ecrit_sat (&bufsat);
texte (T_TRJ + 20);
maj_niv (6, 9, 9);
break;
case 9:
lit_sat (&bufsat);
if (ISGRAPH (*indd))
bufsat.o0 = atof (indd);
ecrit_sat (&bufsat);
texte (T_TRJ + 21);
maj_niv (6, 9, 10);
break;
case 10:
lit_sat (&bufsat);
if (ISGRAPH (*indd))
bufsat.i0 = atof (indd);
ecrit_sat (&bufsat);
texte (T_TRJ + 22);
maj_niv (6, 9, 11);
break;
case 11:
lit_sat (&bufsat);
if (ISGRAPH (*indd))
bufsat.e0 = atof (indd);
ecrit_sat (&bufsat);
texte (T_TRJ + 23);
maj_niv (6, 9, 12);
break;
case 12:
lit_sat (&bufsat);
if (ISGRAPH (*indd))
{
bufsat.n0 = atof (indd);
bufsat.a0 = 0.0;
}
ecrit_sat (&bufsat);
texte (T_TRJ + 24);
maj_niv (6, 9, 13);
break;
case 13:
lit_sat (&bufsat);
if (ISGRAPH (*indd))
bufsat.q3 = atof (indd);
ecrit_sat (&bufsat);
texte (T_TRJ + 25);
maj_niv (6, 9, 14);
break;
case 14:
lit_sat (&bufsat);
if (ISGRAPH (*indd))
bufsat.pas = atoi (indd);
ecrit_sat (&bufsat);
texte (T_TRJ + 26);
maj_niv (6, 9, 15);
break;
case 15:
lit_sat (&bufsat);
if (ISGRAPH (*indd))
{
bufsat.f1 = atof (indd);
bufsat.v1 = 0.0;
}
ecrit_sat (&bufsat);
texte (T_QST + 2);
maj_niv (6, 0, 0);
prompt (pvoie->finf.flags, pvoie->niv1);
break;
default:
fbb_error (ERR_NIVEAU, "MODIF-SAT", pvoie->niv3);
break;
}
}
static void supprime_sat (void)
{
FILE *fptr;
FILE *tptr;
satel bufsat;
char temp[128];
long pos = 0L;
if ((tptr = fopen (temp_name (voiecur, temp), "wb")) == NULL)
return;
if ((fptr = fopen (d_disque ("SAT\\SATEL.DAT"), "rb")) != NULL)
{
while (fread ((char *) &bufsat, sizeof (satel), 1, fptr))
{
if (pos != pvoie->enrcur)
fwrite ((char *) &bufsat, sizeof (satel), 1, tptr);
pos += (long) sizeof (satel);
}
ferme (fptr, 27);
}
ferme (tptr, 28);
rename_temp (voiecur, d_disque ("SAT\\SATEL.DAT")); /* Le fichier est mis en place */
}
static void ecrit_sat (satel * bufsat)
{
FILE *fptr;
fptr = ouvre_sat ();
fseek (fptr, pvoie->enrcur, 0);
fwrite ((char *) bufsat, sizeof (*bufsat), 1, fptr);
ferme (fptr, 27);
}
void param_satel (void)
{
int i;
satel bufsat;
FILE *fptr;
switch (pvoie->niv3)
{
case 0:
if ((i = selection_sat ()) == -1)
break;
else
{
fptr = ouvre_sat ();
pvoie->enrcur = (long) sizeof (bufsat) * (long) i;
fflush (fptr);
if ((i < 0) || (pvoie->enrcur >= filelength (fileno (fptr))))
{
ferme (fptr, 28);
texte (T_ERR + 0);
menu_sat ();
}
else
{
fseek (fptr, pvoie->enrcur, 0);
fread ((char *) &bufsat, sizeof (bufsat), 1, fptr);
ferme (fptr, 29);
if (*(bufsat.dd))
{
affiche_param (&bufsat);
retour_menu (N_TRAJ);
}
else
{
texte (T_ERR + 3);
menu_sat ();
}
}
}
break;
default:
fbb_error (ERR_NIVEAU, "PARAM-SAT", pvoie->niv3);
break;
}
}
static void affiche_param (satel * bufsat)
{
lit_sat (bufsat);
vis_param (bufsat);
}
static void vis_param (satel * bufsat)
{
var_cpy (0, bufsat->dd);
sprintf (varx[1], "%ld", bufsat->cat);
texte (T_TRJ + 27);
sprintf (varx[0], "%5ld", bufsat->k0);
texte (T_TRJ + 28);
sprintf (varx[0], "%5d", bufsat->y3);
texte (T_TRJ + 29);
sprintf (varx[0], "%14.8f", bufsat->d3);
texte (T_TRJ + 30);
sprintf (varx[0], "%14.8f", bufsat->m0);
texte (T_TRJ + 31);
sprintf (varx[0], "%14.8f", bufsat->w0);
texte (T_TRJ + 32);
sprintf (varx[0], "%14.8f", bufsat->o0);
texte (T_TRJ + 33);
sprintf (varx[0], "%14.8f", bufsat->i0);
texte (T_TRJ + 34);
sprintf (varx[0], "%14.8f", bufsat->e0);
texte (T_TRJ + 35);
sprintf (varx[0], "%14.8f", bufsat->n0);
texte (T_TRJ + 36);
sprintf (varx[0], "%14.8f", bufsat->q3);
texte (T_TRJ + 37);
sprintf (varx[0], "%5d", bufsat->pas);
texte (T_TRJ + 38);
}
void lit_sat (satel * bufsat)
{
FILE *fptr;
fptr = ouvre_sat ();
fseek (fptr, pvoie->enrcur, 0);
fread ((char *) bufsat, sizeof (*bufsat), 1, fptr);
ferme (fptr, 26);
}
int test_date (char *ptr)
{
char *sptr = ptr;
int j, m, a;
struct tm *sdate;
long temps = time (NULL);
sdate = gmtime (&temps);
if (!ISGRAPH (*ptr))
{
sprintf (ptr, "%02d/%02d/%02d", sdate->tm_mday, sdate->tm_mon + 1, sdate->tm_year % 100);
outln (ptr, strlen (ptr));
}
if (!isdigit (*ptr))
return (FALSE);
while (isdigit (*ptr))
++ptr;
if ((!*ptr) || (isalnum (*ptr)))
return (FALSE);
*ptr++ = ' ';
if (!isdigit (*ptr))
return (FALSE);
while (isdigit (*ptr))
++ptr;
if ((!*ptr) || (isalnum (*ptr)))
return (FALSE);
*ptr++ = ' ';
if (!isdigit (*ptr))
return (FALSE);
while (isdigit (*ptr))
++ptr;
if (!ISGRAPH (*ptr))
{
sscanf (sptr, "%d %d %d", &j, &m, &a);
if ((j < 1) || (j > 31))
return (FALSE);
if ((m < 1) || (m > 12))
return (FALSE);
if ((a > 99) && (a < 1980 || a > 2030))
return (FALSE);
return (TRUE);
}
return (FALSE);
}
int test_heure (char *ptr)
{
char *sptr = ptr;
int h, m;
struct tm *sdate;
long temps = time (NULL);
sdate = gmtime (&temps);
if (!ISGRAPH (*ptr))
{
sprintf (ptr, "%02d:%02d", sdate->tm_hour, sdate->tm_min);
outln (ptr, strlen (ptr));
}
if (!isdigit (*ptr))
return (FALSE);
while (isdigit (*ptr))
++ptr;
if ((!*ptr) || (isalnum (*ptr)))
return (FALSE);
*ptr++ = ' ';
if (!isdigit (*ptr))
return (FALSE);
while (isdigit (*ptr))
++ptr;
if (!ISGRAPH (*ptr))
{
sscanf (sptr, "%d %d", &h, &m);
if ((h < 0) || (h > 23))
return (FALSE);
if ((m < 0) || (m > 59))
return (FALSE);
return (TRUE);
}
return (FALSE);
}
void menu_sat (void)
{
int i = 0;
satel bufsat;
FILE *fptr;
char satstr[80];
FILE *fptr2;
cr ();
fptr = ouvre_sat ();
while (fread ((char *) &bufsat, sizeof (bufsat), 1, fptr))
{
sprintf (varx[0], "%3d", i++);
sprintf (varx[1], "%-17s", bufsat.dd);
sprintf (satstr, "sat\\%ld.sat", bufsat.cat);
if ((fptr2 = fbb_fopen( d_disque (satstr),"r+b")) != NULL)
{
strcat (varx[0]," *");
} else
strcat (varx[0]," ");
texte (T_TRJ + 39);
if ((i % 3) == 0)
cr_cond ();
}
ferme (fptr, 30);
if (i % 3)
cr_cond ();
texte (T_TRJ + 40);
texte (T_QST + 5);
}
int selection_sat (void)
{
int i;
switch (toupper (*indd))
{
case '\0':
texte (T_QST + 5);
return (-1);
case 'L':
case 'W':
menu_sat ();
return (-1);
case 'F':
maj_niv (pvoie->niv1, 0, 0);
prompt (pvoie->finf.flags, pvoie->niv1);
return (-1);
default:
if (isdigit (*indd))
{
i = atoi (indd);
return (i);
}
texte (T_ERR + 0);
texte (T_QST + 5);
return (-1);
}
}
void trajec (void)
{
switch (pvoie->niv2)
{
case 0:
menu_trajec ();
break;
case 1:
trajecto ();
break;
case 2:
param_satel ();
break;
case 3:
carac_satel ();
break;
case 9:
modif_satel ();
break;
default:
fbb_error (ERR_NIVEAU, "TRAJEC", pvoie->niv2);
break;
}
}
fbb-7.0.11/src/drv_kam.c 0000664 0001750 0001750 00000036213 13613525371 011645 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
#include
typedef struct
{
char port;
char stream;
}
KamTries;
typedef struct
{
char canal;
char *cmd;
}
KamCmd;
KamTries kam_try[NBPORT];
KamCmd kam_cmd[NBPORT];
static int lit_stat_kam (int port, int canal, stat_ch * ptr);
static int kam_send (int port, int canal, int type, char *chaine, int len);
static int kam_tor (int port, char *chaine, int len);
static int kam_send_dt (int port, int canal, char *buffer, int len);
static int kam_send_ui (int port, char *buffer, int len, Beacon * beacon);
static int kam_inbuf (int *port, int *canal, int *cmd, char *buffer, int *len, ui_header * ui);
/*
* Fonctions g‚n‚riques du driver
*/
int sta_kam (int port, int canal, int cmd, void *ptr)
{
char command[256];
char *cptr = (char *) ptr;
if ((kam_cmd[port].cmd) && (p_port[port].stop == 0))
{
int len = strlen (kam_cmd[port].cmd);
kam_send (port, kam_cmd[port].canal, 1, kam_cmd[port].cmd, len);
m_libere (kam_cmd[port].cmd, len + 1);
kam_cmd[port].cmd = NULL;
}
switch (cmd)
{
case TNCSTAT:
return (lit_stat_kam (port, canal, (stat_ch *) ptr));
case SNDCMD:
/* Teste la commande de connexion delayee */
if ((*cptr == 'C') && (*(cptr + 1) == ' ') && (p_port[port].stop))
{
kam_cmd[port].cmd = m_alloue (strlen (cptr) + 1);
strcpy (kam_cmd[port].cmd, cptr);
kam_cmd[port].canal = canal;
return (1);
}
return (kam_send (port, canal, 1, cptr, strlen (ptr)));
case ECHOCMD:
return (1);
case PORTCMD:
strcpy (command, (char *) ptr);
return (kam_send (port, 0, 1, command, strlen (command)));
}
return (0);
}
int snd_kam (int port, int canal, int cmd, char *buffer, int len, Beacon * ptr)
{
int ret = 0;
switch (cmd)
{
case COMMAND:
ret = kam_send (port, 0, 1, buffer, len);
break;
case TOR:
ret = kam_tor (port, buffer, len);
break;
case DATA:
ret = kam_send_dt (port, canal, buffer, len);
break;
case UNPROTO:
ret = kam_send_ui (port, buffer, len, ptr);
break;
}
return (ret);
}
int rcv_kam (int *port, int *canal, int *cmd, char *buffer, int *len, ui_header * ptr)
{
int val;
val = kam_inbuf (port, canal, cmd, buffer, len, ptr);
return (val);
}
/*************** Driver KAM ************/
static int kam_tor (int port, char *chaine, int len)
{
int c;
df ("kam_tor", 6);
while (car_tx (port))
; /* attend que le buffer d'emission soit vide */
send_tnc (port, 0xc0);
while (len--)
{
c = *chaine++;
if (c == 0xc0)
{
send_tnc (port, 0xdb);
c = 0xdc;
}
else if (c == 0xdb)
{
send_tnc (port, 0xdb);
c = 0xdd;
}
send_tnc (port, c);
}
send_tnc (port, 0xc0);
ff ();
return (1);
}
static int kam_read (int port, char *buffer)
{
int c, nb;
char *ptr = buffer;
df ("kam_read", 3);
nb = 0;
if (!car_tnc (port))
{
ff ();
return (0);
}
if (rec_tnc (port) != 0xc0)
{
++com_error;
ff ();
return (0);
}
for (;;)
{
c = rec_tnc (port);
if (c == -1)
{
continue;
}
if (c == 0xdb)
{
while ((c = rec_tnc (port)) == -1);
switch (c)
{
case 0xdc:
*ptr++ = 0xc0;
break;
case 0xdd:
*ptr++ = 0xdb;
break;
}
++nb;
}
else if (c == 0xc0)
{
if (nb)
break;
else
nb = -1;
}
else if (nb < 300)
{
*ptr++ = c;
++nb;
}
}
ff ();
return (nb);
}
static int kam_send (int port, int canal, int type, char *chaine, int len)
{
int c;
int c_port = 0;
int c_voie = 0;
int c_mode = 0;
int tor = 0;
df ("kam_send", 4);
while (car_tx (port))
; /* attend que le buffer d'emission soit vide */
/* Envoi dans stream 0 en TOR */
if ((tor) && (type == 2))
type = 0;
switch (type)
{
case 0: /* Unproto */
c_mode = 'D';
c_port = p_port[port].ccanal + '0';
c_voie = '0';
break;
case 1: /* Commande */
c_mode = 'C';
c_port = p_port[port].ccanal + '0';
if (canal == 0)
c_voie = '0';
else
c_voie = 'A' + canal - 1;
break;
case 2: /* Data */
c_mode = 'D';
c_port = p_port[port].ccanal + '0';
c_voie = 'A' + canal - 1;
break;
}
send_tnc (port, 0xc0);
send_tnc (port, c_mode);
send_tnc (port, c_port);
send_tnc (port, c_voie);
while (len--)
{
c = *chaine++;
if (c == 0xc0)
{
send_tnc (port, 0xdb);
c = 0xdc;
}
else if (c == 0xdb)
{
send_tnc (port, 0xdb);
c = 0xdd;
}
send_tnc (port, c);
}
send_tnc (port, 0xc0);
ff ();
return (1);
}
static int kam_send_dt (int port, int canal, char *buffer, int len)
{
int retour = 1;
if (len <= 0)
return (0);
df ("kam_send_dt", 5);
retour = kam_send (port, canal, 2, buffer, len);
ff ();
return (retour);
}
static int kam_send_ui (int port, char *buffer, int len, Beacon * beacon)
{
char commande[300];
char s[80];
int i;
int via = 1;
df ("kam_send_ui", 5);
sprintf (commande, "U %s-%d", mot (beacon->desti.call), beacon->desti.num);
for (i = 0; i < 8; i++)
{
if (*beacon->digi[i].call)
{
if (via)
{
strcat (commande, " VIA ");
via = 0;
}
else
{
strcat (commande, ",");
}
sprintf (s, "%s-%d",
mot (beacon->digi[i].call), beacon->digi[i].num);
strcat (commande, s);
}
}
kam_send (port, 0, 1, commande, strlen (commande));
kam_send (port, 0, 0, buffer, len);
ff ();
return (1);
}
static void lit_kam_tries (int port, int canal, char *ptr, stat_ch * sta)
{
int ret;
df ("lit_kam_tries", 2);
sscanf (ptr, "%*s %d", &ret);
sta->ret = ret;
sta->stat = -1;
sta->connect = -1;
sta->ack = -1;
sta->mem = -1;
ff ();
return;
}
static void lit_kam_status (int port, char *ptr, stat_ch * sta)
{
#define NB_KAM_STAT 13
static struct
{
int lg;
char *txt;
}
kam_stat[NB_KAM_STAT] =
{
{
9, "DISCONNEC"
}
,
{
9, "CONNECT i"
}
,
{
9, "FRMR in p"
}
,
{
9, "DISC in p"
}
,
{
9, "CONNECTED"
}
,
{
1, "x"
}
,
{
9, "Waiting a"
}
,
{
9, "Device bu"
}
,
{
9, "Remote de"
}
,
{
9, "Both devi"
}
,
{
17, "Waiting ACK and d"
}
,
{
17, "Waiting ACK and r"
}
,
{
17, "Waiting ACK and b"
}
,
};
int i;
int mod;
int voie;
int stat = 0;
int ack = 0;
int kam_port = 0;
int stream = 0;
int st_kam[MAXVOIES];
char *scan;
df ("lit_kam_status", 3);
sta->ret = -1;
sta->stat = -1;
sta->connect = -1;
sta->ack = -1;
sta->mem = -1;
for (i = 0; i < MAXVOIES; i++)
{
if ((i < NBVOIES) && (svoie[i]->affport.port == port))
st_kam[i] = 0;
else
st_kam[i] = -1;
}
scan = strtok (ptr, "\r");
if (scan == NULL)
{
ff ();
return;
}
sscanf (scan, "%*s %*s %d", &p_port[port].mem);
while ((scan = strtok (NULL, "\r")) != NULL)
{
if (scan[1] != '/')
continue;
stream = scan[0] - '@';
kam_port = (scan[2] == 'V') ? 1 : 2;
if (kam_port == 0)
continue;
mod = 0;
if (p_port[port].ccanal != kam_port)
{
/* Recherche l'autre port du TNC */
for (i = 1; i < NBPORT; i++)
{
if (i == port)
continue;
if (p_port[i].ccom == p_port[port].ccom)
{
port = i;
break;
}
}
}
voie = no_voie (port, stream);
if (voie == -1)
continue;
scan += 4;
if (*scan == '#')
{
while ((*scan) && (*scan != '('))
++scan;
++scan;
ack = 0;
while (isdigit (*scan))
{
ack *= 10;
ack += (*scan - '0');
++scan;
}
scan += 2;
}
else
{
ack = 0;
}
stat = 20;
for (i = 0; i < NB_KAM_STAT; i++)
{
if (strncmp (kam_stat[i].txt, scan, kam_stat[i].lg) == 0)
{
stat = i;
st_kam[voie] = i;
}
}
if ((P_TOR (voie)) && (p_port[no_port (voie)].transmit))
stat = 18;
if (stat == 0)
{
ack = 0;
sta->ret = 0;
}
if (sta->ack != ack)
{
sta->ack = ack;
mod = 1;
}
if (sta->stat != stat)
{
sta->stat = stat;
mod = 1;
}
if (mod)
status (voie);
}
for (voie = 0; voie < MAXVOIES; voie++)
{
if (st_kam[voie] == 0)
{
mod = 0;
if (sta->ack != 0)
{
sta->ack = 0;
mod = 1;
}
if (sta->ret != 0)
{
sta->ret = 0;
mod = 1;
}
if (sta->stat != 0)
{
sta->stat = 0;
mod = 1;
}
if (mod)
status (voie);
}
}
ff ();
return;
}
static int lit_stat_kam (int port, int canal, stat_ch * ptr)
{
static long last_call = 0L;
long temps;
if (ptr)
{
temps = time (NULL);
if (temps == last_call)
return (0);
last_call = temps;
}
df ("lit_stat_kam", 1);
if (kam_try[(int)p_port[port].ccom].port == 0)
{
kam_try[(int)p_port[port].ccom].port = (char) port;
kam_try[(int)p_port[port].ccom].stream = (char) canal;
kam_send (port, 0, 1, "STATUS", 6);
kam_send (port, canal, 1, "TRIES", 5);
}
ff ();
return (0);
}
static void kam_get_ui (int port, char *buffer, ui_header * ui)
{
char *ptr;
char *sptr;
memset (ui, 0, sizeof (ui_header));
ui->port = port;
ptr = strtok (buffer, ">"); /* exped */
if (ptr == NULL)
return;
n_cpy (11, ui->from, ptr);
ptr = strtok (NULL, ":,"); /* desti */
if (ptr == NULL)
return;
n_cpy (11, ui->to, ptr);
ptr = strtok (NULL, ":,"); /* digis */
if (ptr == NULL)
return;
if (*ptr != ' ')
{
for (;;)
{
strncat (ui->via, ptr, 12);
strcat (ui->via, " ");
ptr = strtok (NULL, ":,"); /* digis */
if (ptr == NULL)
return;
if ((*ptr == '\0') || (*ptr == ' '))
break;
}
}
++ptr;
sptr = ptr;
while ((*sptr) && (*sptr != '>'))
++sptr;
*sptr = '\0';
/* controle */
*ui->ctl = '\0';
if (ptr[0] == '<')
{
int pos = 0;
int version = 1;
int reponse = 0;
++ptr;
if (ptr[0] == '<')
{
version = 2;
/* AX25 Version 2 */
++ptr;
}
sptr = ptr;
if (*sptr == 'F')
{
pos = 4;
}
else if (*sptr == 'U')
{
pos = 2;
if (sptr[1] == 'A')
reponse = 1;
}
else if (*sptr == 'C')
{
strcpy (ptr, "SABM");
pos = 4;
}
else if (*sptr == 'D')
{
strcpy (ptr, "DISC");
pos = 4;
}
else if (*sptr == 'I')
{
pos = 3;
}
else
{
if (*sptr == 'r')
{
strupr (sptr);
reponse = 1;
}
if (sptr[1] == 'R')
pos = 3;
else
pos = 4;
}
if (version == 1)
{
if (reponse)
sptr[pos] = '\0';
else
sptr[pos] = '!';
}
else
{
if (reponse)
sptr[pos] = '-';
else
sptr[pos] = '+';
}
sptr[pos + 1] = '\0';
n_cpy (4, ui->ctl, ptr);
}
ui->ui = (strncmp (ui->ctl, "UI", 2) == 0);
ui->pid = 0xf0;
}
static int kam_inbuf (int *port, int *canal, int *cmd, char *buffer, int *len, ui_header * ui)
{
int nbcar, can;
int type;
int i, lport;
int valid = 0;
int deja;
char stemp[80];
static char buf[600];
char *ptr;
df ("lit_txt_kam", 1);
if ((nbcar = kam_read (*port, buf)) >= 3)
{
lport = (int) (*(buf + 1) - '0');
if (p_port[*port].ccanal != lport)
{
/* Recherche l'autre port du TNC */
for (i = 1; i < NBPORT; i++)
{
if (i == *port)
continue;
if (p_port[i].ccom == p_port[*port].ccom)
{
*port = i;
break;
}
}
}
type = (int) *buf;
can = (int) (*(buf + 2) - 'A') + 1;
switch (type)
{
case 'M':
ptr = buf + 3;
nbcar -= 3;
deja = 0;
while ((*ptr) && (nbcar))
{
--nbcar;
if (*ptr++ == ':')
{
if (deja)
{
break;
}
deja = 1;
}
}
kam_get_ui (*port, buf + 3, ui);
if (nbcar > 0)
{
++ptr;
--nbcar;
memcpy (buffer, ptr, nbcar);
sprintf (ui->txt, " (%d)", nbcar);
}
else
nbcar = 0;
valid = 1;
*cmd = UNPROTO;
*canal = can;
*len = nbcar;
break;
case 'S':
nbcar -= 3;
ptr = buf + 3;
ptr[nbcar] = '\0';
*buffer = '\0';
*len = 0;
/* TOR modes ... */
if (strncmp (ptr, "')
stemp[strlen (stemp) - 1] = '\0';
sprintf (buffer, "(%d) CONNECTED to %s", can, stemp);
valid = 1;
*cmd = COMMAND;
*canal = 1;
*len = strlen (buffer);
break;
}
else if (strstr (ptr, "STANDBY"))
{
sprintf (buffer, "(%d) DISCONNECTED fm KAM", can);
p_port[*port].transmit = 0;
valid = 1;
*cmd = COMMAND;
*canal = 1;
*len = strlen (buffer);
if ((p_port[*port].moport & 0x80) == 0)
{
/* Retour en mode packet */
kam_tor (*port, "X", 1);
}
break;
}
else if (*ptr != '*')
break;
ptr += 4;
*buffer = '\0';
switch (*ptr)
{
case 'C':
valid = 1;
sscanf (ptr, "%*s %*s %s", stemp);
sprintf (buffer, "(%d) CONNECTED to %s", can, stemp);
/* Connection */
break;
case 'D':
valid = 1;
sprintf (buffer, "(%d) DISCONNECTED fm KAM", can);
/* Deconnection */
break;
case 'r':
valid = 1;
sprintf (buffer, "(%d) LINK FAILURE with KAM", can);
break;
default:
valid = 0;
break;
}
*cmd = COMMAND;
*canal = can;
*len = strlen (buffer);
break;
case 'D':
nbcar -= 3;
memcpy (buffer, buf + 3, nbcar);
valid = 1;
*cmd = DATA;
if (can < 0)
can = 1;
*canal = can;
*len = nbcar;
break;
case 'C':
nbcar -= 3;
memcpy (buffer, buf + 3, nbcar);
*len = 0;
*cmd = NOCMD;
if (nbcar > 0)
{
if (strncmp (buf + 3, "FREE", 4) == 0)
{
stat_ch sta;
int tnc = p_port[*port].ccom;
memset (&sta, 0, sizeof (sta));
*port = kam_try[tnc].port;
can = kam_try[tnc].stream;
lit_kam_status (*port, buf + 3, &sta);
memcpy (buffer, &sta, sizeof (sta));
valid = 1;
*cmd = STATS;
*canal = can;
*len = 0;
}
else if (strncmp (buf + 3, "TRIES", 5) == 0)
{
stat_ch sta;
int tnc = p_port[*port].ccom;
memset (&sta, 0, sizeof (sta));
*port = kam_try[tnc].port;
can = kam_try[tnc].stream;
lit_kam_tries (*port, can, buf + 3, &sta);
memcpy (buffer, &sta, sizeof (sta));
valid = 1;
*cmd = STATS;
*canal = can;
*len = 0;
kam_try[tnc].port = 0;
}
else
{
valid = 1;
*cmd = ECHOCMD;
*canal = can;
*len = nbcar;
}
}
break;
case 'R':
nbcar -= 3;
memcpy (buffer, buf + 3, nbcar);
valid = 1;
*cmd = UNPROTO;
*canal = can;
*len = nbcar;
break;
case 'I':
valid = 0;
*cmd = TOR;
p_port[*port].transmit = (can != '0');
*len = 0;
break;
default:
break;
}
}
ff ();
return (valid);
}
void env_com_kam (int port, int canal, char *buffer)
{
if (toupper (*buffer) == 'B')
{
paclen_change (port, canal, buffer);
}
else
{
kam_send (port, 0, 1, buffer, strlen (buffer));
*buffer = '\0';
}
}
fbb-7.0.11/src/fwdutil.c 0000664 0001750 0001750 00000036201 14131613540 011665 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
/*
* MODULE FWDUTIL.C
*/
#include
static long hold_nb = 0L;
static void append_message (void);
static int data_sysop (void);
static int hold_wp (void);
/*
* RECEPTION D'UN MESSAGE
*/
void libere (int voie)
{
obuf *msgtemp;
while ((msgtemp = svoie[voie]->msgtete) != NULL)
{
svoie[voie]->memoc -= msgtemp->nb_car;
svoie[voie]->msgtete = msgtemp->suiv;
m_libere ((char *) msgtemp, sizeof (obuf));
msgtemp = NULL;
}
svoie[voie]->entmes.numero = 0L;
}
void supp_mess (long nmess)
{
char temp[128];
if (nmess)
unlink (mess_name ((pvoie->binary) ? MBINDIR : MESSDIR, nmess, temp));
}
int write_mess_temp (unsigned mode, int voie)
{
int fd;
obuf *msgtemp;
char temp[128];
temp_name (voie, temp);
fd = open (temp, O_WRONLY | O_APPEND | O_CREAT | mode, S_IREAD | S_IWRITE);
if (fd != -1)
{
while ((msgtemp = pvoie->msgtete) != NULL)
{
if (write (fd, msgtemp->buffer, msgtemp->nb_car) != msgtemp->nb_car)
{
write_error (temp);
}
pvoie->memoc -= msgtemp->nb_car;
pvoie->msgtete = msgtemp->suiv;
m_libere ((char *) msgtemp, sizeof (*msgtemp));
}
close (fd);
return (1);
}
else
{
fbb_error (ERR_OPEN, temp, 0);
return (0);
}
}
#if 0
int write_mess (unsigned mode, long nmess)
{
int fd;
obuf *msgtemp;
if (nmess == 0L)
nmess = next_num ();
fd = open (nom_mess ((mode == O_BINARY) ? MBIN : MESS, nmess), O_WRONLY | O_APPEND | O_CREAT | mode, S_IREAD | S_IWRITE);
if (fd != -1)
{
while (msgtemp = pvoie->msgtete)
{
if (write (fd, msgtemp->buffer, msgtemp->nb_car) != msgtemp->nb_car)
{
write_error ();
}
pvoie->memoc -= msgtemp->nb_car;
pvoie->msgtete = msgtemp->suiv;
m_libere ((char *) msgtemp, sizeof (*msgtemp));
}
close (fd);
return (1);
}
else
{
write_error ();
return (0);
}
}
#endif
static void append_message (void)
{
int nb;
FILE *fd, *fich_ptr;
char buffer[250];
if ((fich_ptr = fopen (pvoie->appendf, "rb")) == NULL)
{
texte (T_ERR + 11);
}
else
{
next_num ();
if ((fd = fopen (mess_name (MESSDIR, ptmes->numero, buffer), "ab")) != NULL)
{
while (1)
{
fflush (fich_ptr);
nb = read (fileno (fich_ptr), buffer, 250);
ptmes->taille += nb;
if (fwrite (buffer, nb, 1, fd) < 1)
write_error (mess_name (MESSDIR, ptmes->numero, buffer));
if (nb < 250)
break;
}
ferme (fd, 45);
}
ferme (fich_ptr, 44);
if (voiecur == CONSOLE)
texte (T_MBL + 20);
}
}
void ins_fwd (bullist * fwd_rec)
{
int pos;
lfwd *ptr_fwd;
char *ptr = NULL;
ptr_fwd = tete_fwd;
pos = 0;
if (fwd_rec->numero == 0L)
return;
if (ptr_fwd == NULL)
{
cprintf ("ptr_fwd = NULL !!!\n");
*ptr = 0;
}
while (1)
{
if (pos == NBFWD)
{
if (ptr_fwd->suite == NULL)
ptr_fwd = cree_bloc_fwd (ptr_fwd);
else
ptr_fwd = ptr_fwd->suite;
pos = 0;
}
if (ptr_fwd->fwd[pos].type == '\0')
{
fwd_cpy (&ptr_fwd->fwd[pos], fwd_rec);
break;
}
++pos;
}
}
static void test_ping_pong (bullist * lbul)
{
int i;
if ((lbul->type != 'P') || (*lbul->bbsv == '\0'))
return;
if (pvoie->warning & W_ROU)
return;
for (i = 0; i < NBMASK; i++)
if (lbul->fbbs[i])
return;
/* Ya une bbs, pas de warning et pas de route -> ping-pong ! */
dde_warning (W_PPG);
}
static int data_sysop (void)
{
if ((std_header & 32) &&
(strcmp (ptmes->desti, "SYSOP") == 0) &&
(ptmes->type == 'P') &&
(ptmes->bin))
{
return (1);
}
else
return (0);
}
static int hold_wp (void)
{
if ((std_header & 256) && (strcmp (ptmes->desti, "WP") == 0))
return (0);
return (1);
}
int is_held (char *ascfile)
{
long temps;
char holdname[130];
int i;
int nobbs;
char status = '\0';
char s[256];
long numess = ptmes->numero;
/* Invoke M_FILTER when found */
if (through_mfilter)
{
int ret = -1;
/* Ecrire les infos ptmes dans le record 0 de DIRMES.SYS */
ptmes->numero = nomess;
ouvre_dir ();
write_dir (0, ptmes);
ferme_dir ();
ptmes->numero = numess;
#ifdef __linux__
sprintf (s, "./m_filter %s %c %s %s %d",
ascfile, ptmes->type, ptmes->exped, ptmes->desti, 0);
ret = filter (s, NULL, 0, NULL, FILTDIR);
#else
sprintf (s, "m_filter %s %c %s %s %d",
ascfile, ptmes->type, ptmes->exped, ptmes->desti, 0);
ret = filter (s, NULL, 0, NULL, NULL);
#endif
switch (ret)
{
case -1:
/* M_FILTER is not found ... Will not be called again */
fprintf (stderr, "No message filter (M_FILTER) found, FBB skips trying on subsequent messages\n");
through_mfilter = 0;
break;
case 1: /* Kill */
for (i = 0; i < NBMASK; i++)
ptmes->fbbs[i] = ptmes->forw[i] = '\0';
status = 'K';
break;
case 2: /* Archive */
for (i = 0; i < NBMASK; i++)
ptmes->fbbs[i] = ptmes->forw[i] = '\0';
status = 'A';
break;
case 3: /* Hold */
for (i = 0; i < NBMASK; i++)
ptmes->fbbs[i] = ptmes->forw[i] = '\0';
if ((FOR (pvoie->mode)) && ((nobbs = n_bbs (pvoie->sta.indicatif.call)) != 0))
set_bit_fwd (ptmes->forw, nobbs);
status = 'H';
break;
default:
break;
}
if (status)
ptmes->status = status;
/* With K or A status set by M_FILTER also store bid for later dupe checks */
if (((status == 'K') || (status == 'A')) && *ptmes->bid)
w_bid ();
}
if ((hold_wp ()) && ((pvoie->msg_held) || (status == 'H') || (hold (ptmes))))
{
/* Le message est HOLD. Il n'est pas gere, mais mis dans le repertoire HOLD */
ptmes->status = 'H';
++nb_hold;
if (*ptmes->bid)
{
// held messages get in a separate list, don't store bid with wrong message number but use 0 instead
ptmes->numero = 0;
w_bid ();
}
if ((FOR (pvoie->mode)) && ((nobbs = n_bbs (pvoie->sta.indicatif.call)) != 0))
set_bit_fwd (ptmes->forw, nobbs);
/* Cree un index du nom de fichier */
temps = time (NULL);
if (hold_nb >= temps)
++hold_nb;
else
hold_nb = temps;
for (;;)
{
hold_name (hold_nb, holdname);
if (access (holdname, 0) != 0)
{
hold_temp (voiecur, ascfile, holdname, TRUE);
break;
}
++hold_nb;
}
if (!FOR (pvoie->mode))
{
texte (T_MBL + 59);
}
aff_msg_cons (); /* Affiche cons + held */
return (1);
}
return (0);
}
void put_mess_fwd (char clog)
{
int i;
char s[256];
long numess = ptmes->numero;
if (*(pvoie->appendf))
append_message ();
if ((strncmp (ptmes->titre, "ACK", 3) != 0) &&
(strcmp (ptmes->exped, "WP") != 0) &&
(find (ptmes->exped)) &&
(!is_serv (ptmes->exped)) &&
(pvoie->niv2 != 99))
{
exped_wp (ptmes->exped, pvoie->mess_home);
}
if ((ptmes->status != 'K') && (ptmes->status != 'A'))
{
if (ptmes->type == 'B')
valide_themes (0, 1, ptmes);
if (test_forward (1))
ins_fwd (ptmes);
test_ping_pong (ptmes);
if (!(FOR (pvoie->mode)))
texte (T_MBL + 48);
}
if (clog)
{
sprintf (s, "%c %ld%c F:%s T:%s@%s [%ld] S:%s",
clog, ptmes->numero, ptmes->type, ptmes->exped,
ptmes->desti, ptmes->bbsv, ptmes->taille, ptmes->titre);
fbb_log (voiecur, 'M', s);
}
libere (voiecur);
flush_wp_cache ();
pvoie->mess_recu = 1;
pvoie->header = 0;
ptmes->numero = numess;
/* Supprime le message si datas en "SP SYSOP" */
if (data_sysop ())
{
for (i = 0; i < NBMASK; i++)
ptmes->fbbs[i] = ptmes->forw[i] = '\0';
ptmes->status = 'K';
clear_fwd (numess);
}
valmess (ptmes);
++nbmess;
ins_iliste (ptmes);
#ifdef __linux__
add_pfh (ptmes);
#endif
aff_msg_cons ();
}
void tst_ack (bullist * pbul)
{
int nb;
int numlang = vlang;
char temp;
bullist psauve;
char titre[90];
char texte[80];
char suite[80];
int mode = pvoie->binary;
psauve = *pbul;
if (pvoie->m_ack != 2)
return;
pvoie->m_ack = 0;
set_binary (voiecur, 0);
vlang = 0;
if (*psauve.bbsv)
{
sprintf (suite, " - routed to %s", psauve.bbsv);
}
else
*suite = '\0';
sprintf (titre, "ACK:%s", psauve.titre);
sprintf (texte, "Msg %s@%s - %sz%s\032",
psauve.desti, mycall, datheure_mbl (time (NULL) + _timezone), suite);
vlang = numlang;
ini_champs (voiecur);
*ptmes->bbsf = '\0';
temp = *(pvoie->sta.indicatif.call);
*(pvoie->sta.indicatif.call) = '@';
strn_cpy (6, ptmes->desti, psauve.exped);
strn_cpy (6, ptmes->exped, mycall);
n_cpy (60, ptmes->titre, titre);
if (routage (psauve.numero))
{
swapp_bbs (ptmes);
ptmes->type = 'A';
ptmes->status = 'N';
reacheminement ();
nb = strlen (texte);
/* texte[nb] = '\032' ; */
get_mess_fwd ('\0', texte, nb, 2);
}
*(pvoie->sta.indicatif.call) = temp;
*pbul = psauve;
set_binary (voiecur, mode);
}
void tst_sysop (char *desti, long numero)
{
char buffer[80];
char sauv_ind[7];
bullist ptsauv = *ptmes;
int mode = pvoie->binary;
Msysop *sptr = mess_sysop;
if (data_sysop ())
return;
if ((sptr) && (strcmp (desti, "SYSOP") == 0))
{
if (!find (ptmes->bbsv))
{
set_binary (voiecur, 0);
strn_cpy (6, sauv_ind, pvoie->sta.indicatif.call);
strn_cpy (6, pvoie->sta.indicatif.call, "SYSOP");
while (sptr)
{
sprintf (buffer, "P %s", sptr->call);
copy_mess (numero, buffer, '\032');
sptr = sptr->next;
}
strn_cpy (6, pvoie->sta.indicatif.call, sauv_ind);
}
}
*ptmes = ptsauv;
set_binary (voiecur, mode);
}
int get_mess_fwd (char clog, char *ptr, int nbcar, int type)
{
int ncars, debut = 1;
int held = 0;
long numess = 0L;
obuf *msgtemp;
char fin[2];
char *ptcur;
char temp[128];
if ((msgtemp = pvoie->msgtete) != NULL)
{
while (msgtemp->suiv)
msgtemp = msgtemp->suiv;
}
else
{
msgtemp = (obuf *) m_alloue (sizeof (obuf));
pvoie->msgtete = msgtemp;
msgtemp->nb_car = msgtemp->no_car = 0;
msgtemp->suiv = NULL;
}
ncars = msgtemp->nb_car;
ptcur = msgtemp->buffer + ncars;
while (nbcar--)
{
if (debut)
{
if ((pvoie->entete) && (*ptr == 'R') && (*(ptr + 1) == ':'))
{
analyse_header (voiecur, ptr);
}
else
{
pvoie->entete = 0;
}
if ((*ptr == '/') && (toupper (*(ptr + 1)) == 'A') && (toupper (*(ptr + 2)) == 'C'))
{
if (pvoie->m_ack == 1)
{
pvoie->m_ack = 2;
}
}
check_bin (ptmes, ptr);
if ((*ptr == '/') && (toupper (*(ptr + 1)) == 'A') && (toupper (*(ptr + 2)) == 'B'))
{
/* Message aborted */
texte (T_MBL + 21);
type = 4;
*ptr = '\32';
}
if ((*ptr == '\32') || ((*ptr == '/') && (toupper (*(ptr + 1)) == 'E') && (toupper (*(ptr + 2)) == 'X')))
{
int test;
msgtemp->nb_car = ncars;
if (type != 4)
{
/* Le BID existe ? -> message rejete ! */
if (((*ptmes->bid == '\0') || (*ptmes->bid == ' ')) &&
(((pvoie->mess_num != -1) && (*pvoie->mess_home)) ||
(*pvoie->mess_bid)))
{
make_bid ();
if (deja_recu (ptmes, 1, &test) == 1)
{
type = 4;
if (!(FOR (pvoie->mode)))
texte (T_MBL + 45);
}
}
if (pvoie->header)
strn_cpy (6, ptmes->bbsf, pvoie->sta.indicatif.call);
else
*(ptmes->bbsf) = '\0';
ptmes->datesd = pvoie->messdate;
ptmes->date = ptmes->datech = time (NULL); /* Mettre localtime ? */
if (type < 3)
{
/* Flush des buffers */
/* pdebug("(%d) create message file %s", voiecur, temp_name (voiecur, temp)); */
write_mess_temp (O_TEXT, voiecur);
/* tester is hold ? */
if (is_held (temp_name (voiecur, temp)))
held = 1;
else
{
numess = ptmes->numero = next_num ();
rename_temp (voiecur, mess_name (MESSDIR, numess, temp));
}
}
}
switch (type)
{
case 0:
if (!held)
{
put_mess_fwd (clog);
tst_sysop (ptmes->desti, numess);
tst_serveur (ptmes);
tst_ack (ptmes);
tst_warning (ptmes);
}
retour_menu ((pvoie->mbl) ? N_MBL : N_MENU);
/* deconnexion si fin de message */
if (save_fic)
pvoie->deconnect = 6;
break;
case 1:
if (!held)
{
put_mess_fwd (clog);
tst_sysop (ptmes->desti, numess);
tst_serveur (ptmes);
tst_ack (ptmes);
tst_warning (ptmes);
}
maj_niv (pvoie->niv1, pvoie->niv2, 0);
texte (T_MBL + 42);
/* deconnexion si fin de message */
if (save_fic)
pvoie->deconnect = 6;
break;
case 2:
if (!held)
{
put_mess_fwd (clog);
tst_sysop (ptmes->desti, numess);
tst_serveur (ptmes);
tst_ack (ptmes);
tst_warning (ptmes);
}
/* deconnexion si fin de message */
if (save_fic)
pvoie->deconnect = 6;
break;
case 3:
del_temp (voiecur);
libere (voiecur);
break;
case 4:
del_temp (voiecur);
libere (voiecur);
if (voiecur != INEXPORT)
retour_menu ((pvoie->mbl) ? N_MBL : N_MENU);
break;
}
return (1);
}
}
else
{
if (*ptr == '\32')
{
fin[0] = '\r';
fin[1] = '\32';
ptr = fin;
nbcar = 1;
debut = 1;
}
}
if (*ptr == '\n')
++ptr;
else
{
if (*ptr == '\r')
{
*ptr = '\n';
if ((nbcar > 0) && (*(ptr + 1) == '\n'))
{
--nbcar;
++ptr;
}
debut = 1;
}
else
debut = 0;
++pvoie->memoc;
++(ptmes->taille);
*ptcur++ = *ptr++;
if (++ncars == 250)
{
msgtemp->nb_car = ncars;
msgtemp->suiv = (obuf *) m_alloue (sizeof (obuf));
msgtemp = msgtemp->suiv;
msgtemp->nb_car = msgtemp->no_car = ncars = 0;
msgtemp->suiv = NULL;
ptcur = msgtemp->buffer;
}
}
}
msgtemp->nb_car = ncars;
if (pvoie->memoc > MAXMEM)
{
if (type != 3)
write_mess_temp (O_TEXT, voiecur);
else
libere (voiecur);
}
return (0);
}
int mbl_hold (void)
{
long no;
long temps;
char holdname[130];
char filename[130];
if ((toupper (*indd) == 'O') && (droits (COSYSOP)))
{
++indd;
if (!teste_espace ())
{
texte (T_ERR + 2);
retour_mbl ();
return (0);
}
if (((no = lit_chiffre (1)) != 0L) && (ch_record (NULL, no, ' ') != NULL) && (ptmes->status != 'A'))
{
mess_name (MESSDIR, no, filename);
/* Cree un index du nom de fichier */
temps = time (NULL);
if (hold_nb >= temps)
++hold_nb;
else
hold_nb = temps;
for (;;)
{
hold_name (hold_nb, holdname);
if (access (holdname, 0) != 0)
{
hold_temp (voiecur, filename, holdname, FALSE);
break;
}
++hold_nb;
}
++nb_hold;
texte (T_MBL + 59);
/* Passe le message en status ARCHIVE caché ... */
ch_record (NULL, no, 'Z');
/* Supprime le message de la liste des fwd */
clear_fwd (no);
aff_msg_cons (); /* Affiche cons + held */
}
else
texte (T_ERR + 10);
retour_mbl ();
return (0);
}
return (1);
}
fbb-7.0.11/src/mbl_rev.c 0000664 0001750 0001750 00000024324 13613525371 011650 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
#include
/*
* Module MBL_REV.C
*/
#include "aff_stat.c"
#define REV_HOLD 100
typedef struct rev_list
{
long hold[REV_HOLD];
struct rev_list *next;
}
RevList;
static RevList *hold_list = NULL;
static int off_hlist = REV_HOLD;
static int longcmp (const void *a, const void *b)
{
long la = *((long *) a);
long lb = *((long *) b);
if (la == lb)
return (0);
return (la < lb) ? -1 : 1;
}
static int exist_hold (long numero)
{
char holdname[130];
struct stat stat;
hold_name (numero, holdname);
return (stat (holdname, &stat) == 0);
}
void end_hold (void)
{
int i;
RevList *rptr = hold_list;
RevList *prev = NULL;
while (rptr)
{
for (i = 0; i < REV_HOLD; i++)
{
if (!exist_hold (rptr->hold[i]))
rptr->hold[i] = 0L;
if (rptr->hold[i] != 0L)
break;
}
if (i == REV_HOLD)
{
/* Le bloc est vide, on relie les chainons valides et on le libere */
if (prev)
{
/* Il y a un chainon avant */
prev->next = rptr->next;
}
else
{
/* C'etait la tete de liste */
hold_list = rptr->next;
}
/* Si le dernier bloc est libere, on prepare l'allocation d'un nouveau bloc */
if (rptr->next == NULL)
off_hlist = REV_HOLD;
m_libere (rptr, sizeof (RevList));
if (prev)
rptr = prev->next;
else
rptr = hold_list;
}
else
{
prev = rptr;
rptr = rptr->next;
}
}
}
int already_held (long numero)
{
int i;
RevList *rptr = hold_list;
while (rptr)
{
for (i = 0; i < REV_HOLD; i++)
if (rptr->hold[i] == numero)
return 1;
rptr = rptr->next;
}
return 0;
}
int delete_hold (long numero)
{
int i;
RevList *rptr = hold_list;
while (rptr)
{
for (i = 0; i < REV_HOLD; i++)
{
if (rptr->hold[i] == numero)
{
rptr->hold[i] = 0L;
return 1;
}
}
rptr = rptr->next;
}
return 0;
}
void ajoute_hold (long numero)
{
RevList *rptr = hold_list;
if (already_held (numero))
return;
if (rptr)
{
/* Avance jusqu'au dernier maillon */
while (rptr->next)
{
rptr = rptr->next;
}
}
if (off_hlist == REV_HOLD)
{
RevList *ptmp;
/* Ajoute un maillon a la liste */
ptmp = m_alloue (sizeof (RevList));
memset (ptmp, 0, sizeof (RevList));
off_hlist = 0;
if (rptr)
{
rptr->next = ptmp;
}
else
hold_list = rptr = ptmp;
}
rptr->hold[off_hlist++] = numero;
}
void init_hold (void)
{
int done;
long num;
int i;
int nb;
long *hold_nb;
char path[130];
struct ffblk ffblk;
/* Cree ou remet la liste a jour. Les entrees non valides sont a 0 */
end_hold ();
sprintf (path, "%s*.HLD", MESSDIR);
/* Chercher le nombre de messages held */
nb = 0;
done = findfirst (path, &ffblk, 0);
while (!done)
{
++nb;
done = findnext (&ffblk);
}
if (nb)
{
hold_nb = (long *) malloc (nb * sizeof (long));
i = 0;
/* Lire les noms de messages held */
done = findfirst (path, &ffblk, 0);
while (!done)
{
sscanf (ffblk.ff_name, "%lx", &num);
hold_nb[i] = num;
if (++i > nb)
break;
done = findnext (&ffblk);
}
/* Tri de la liste */
qsort (hold_nb, nb, sizeof (long), longcmp);
/* Insere les numeros tries dans la liste */
for (i = 0; i < nb; i++)
ajoute_hold (hold_nb[i]);
free (hold_nb);
}
nb_hold = nb;
}
static int next_hold (void)
{
int fd;
int retour = 1;
bullist lbul;
char holdname[130];
int i=0;
RevList *rptr = hold_list;
while (rptr)
{
for (i = 0; i < REV_HOLD; i++)
{
if (rptr->hold[i] > pvoie->l_hold)
{
pvoie->l_hold = rptr->hold[i];
break;
}
}
if (i != REV_HOLD)
break;
rptr = rptr->next;
}
if ((rptr == NULL) || (i == REV_HOLD))
{
/* Pas de message suivant */
texte (T_MBL + 3);
return retour;
}
hold_name (pvoie->l_hold, holdname);
fd = open (holdname, O_RDONLY | O_BINARY);
read (fd, &lbul, sizeof (bullist));
close (fd);
cr ();
*ptmes = lbul;
ptmes->numero = ++pvoie->temp1;
entete_liste ();
aff_status (ptmes);
retour = 2;
pvoie->messdate = ptmes->datesd;
return (retour);
}
static int read_hold (int verbose)
{
int nb;
FILE *fptr;
char chaine[256];
char holdname[130];
nb = 0;
hold_name (pvoie->l_hold, holdname);
if ((fptr = fopen (holdname, "rt")) != NULL)
{
fseek (fptr, pvoie->enrcur, 0);
if (!verbose)
{
pvoie->enrcur = supp_header (fptr, 1);
fseek (fptr, pvoie->enrcur, 0);
}
fflush (fptr);
while ((nb = read (fileno (fptr), chaine, 250)) > 0)
{
outs (chaine, nb);
if (pvoie->memoc >= MAXMEM)
{
/* if (!getvoie(CONSOLE]->connect) cprintf("Max atteint\r\n") ; */
pvoie->enrcur = ftell (fptr);
break;
}
}
ferme (fptr, 45);
}
else
return (-1);
return (nb);
}
void list_held (void)
{
char holdname[130];
int fd;
bullist lbul;
int premier = 1;
int i;
RevList *rptr;
init_hold ();
rptr = hold_list;
while (rptr)
{
for (i = 0; i < REV_HOLD; i++)
{
if (rptr->hold[i])
{
hold_name (rptr->hold[i], holdname);
fd = open (holdname, O_RDONLY | O_BINARY);
read (fd, &lbul, sizeof (bullist));
close (fd);
*ptmes = lbul;
ptmes->numero = pvoie->temp1 + 1;
if (premier)
{
premier = 0;
entete_liste ();
}
aff_status (ptmes);
++pvoie->temp1;
}
}
rptr = rptr->next;
}
if (premier)
texte (T_MBL + 3);
}
static void hold_question (void)
{
texte (T_MBL + 58);
}
int review (void)
{
int orig;
int dest;
int local = 0;
int verbose = 0;
int error = 0;
long numess;
char holdname[130];
char messname[130];
switch (pvoie->niv3)
{
case 0:
init_hold ();
pvoie->l_hold = 0L;
pvoie->temp1 = 0;
switch (next_hold ())
{
case 0:
ch_niv3 (1);
break;
case 1:
retour_mbl ();
break;
case 2:
hold_question ();
ch_niv3 (2);
break;
}
break;
case 1:
switch (next_hold ())
{
case 0:
break;
case 1:
retour_mbl ();
break;
case 2:
hold_question ();
ch_niv3 (2);
break;
}
break;
case 2:
while_space ();
switch (toupper (*indd))
{
case 'V':
verbose = 1;
case 'R':
/* Lire le message held */
pvoie->sr_mem = 0;
pvoie->enrcur = 256L;
switch (read_hold (verbose))
{
case 0:
pvoie->sr_mem = 0;
hold_question ();
ch_niv3 (2);
break;
case -1:
retour_mbl ();
break;
default:
ch_niv3 (3);
break;
}
/*
indd = data;
sprintf(data, "%ld", ptmes->numero);
list_read(verbose);
if (mbl_mess_read() == 0) {
pvoie->sr_mem = 0;
hold_question();
ch_niv3(2);
}
else
ch_niv3(3);
*/
break;
case 'A':
case 'K':
case 'D':
unlink (hold_name (pvoie->l_hold, holdname));
delete_hold (pvoie->l_hold);
--nb_hold;
aff_msg_cons ();
switch (next_hold ())
{
case 0:
ch_niv3 (1);
break;
case 1:
retour_mbl ();
break;
case 2:
hold_question ();
ch_niv3 (2);
break;
}
break;
case 'L':
local = 1;
case 'U':
/* Unhold */
*(pvoie->appendf) = '\0';
*(pvoie->mess_bid) = '\0';
ptmes->numero = 0L;
ptmes->theme = 0;
pvoie->chck = 0;
pvoie->m_ack = 0;
pvoie->messdate = time (NULL);
pvoie->mess_num = -1;
if ((ptmes->type == 'B') || ((ptmes->type == 'P') && (strcmp (ptmes->desti, "SYSOP") == 0)))
{
if (*(ptmes->bbsv))
ptmes->status = '$';
else
ptmes->status = 'N';
}
else
ptmes->status = 'N';
/* Copier le fichier avec un nouveau No de message */
hold_name (pvoie->l_hold, holdname);
orig = open (holdname, O_RDONLY | O_BINARY);
if (orig < 0)
{
retour_mbl ();
break;
}
/* Saute le header */
lseek (orig, (long) sizeof (bullist), SEEK_SET);
/* Lit le home-bbs */
fbb_read (orig, pvoie->mess_home, sizeof (pvoie->mess_home));
pvoie->mess_home[sizeof (pvoie->mess_home) - 1] = '\0';
/* Debut du texte */
lseek (orig, 256L, SEEK_SET);
/* Cree un nouveau message */
numess = ptmes->numero = next_num ();
mess_name (MESSDIR, ptmes->numero, messname);
dest = open (messname, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, S_IREAD | S_IWRITE);
if (dest < 0)
{
close (orig);
retour_mbl ();
break;
}
copy_fic (orig, dest, NULL);
close (orig);
close (dest);
unlink (holdname);
delete_hold (pvoie->l_hold);
--nb_hold;
put_mess_fwd ('H');
if (local)
{
/* Pas de forwarding ... */
int i;
for (i = 0; i < NBMASK; i++)
{
ptmes->forw[i] = 0xff;
ptmes->fbbs[i] = '\0';
}
maj_rec (ptmes->numero, ptmes);
clear_fwd (ptmes->numero);
/* Supprimer le via */
ptmes->bbsv[0] = '\0';
}
tst_sysop (ptmes->desti, numess);
tst_serveur (ptmes);
tst_ack (ptmes);
tst_warning (ptmes);
aff_msg_cons ();
cr ();
switch (next_hold ())
{
case 0:
ch_niv3 (1);
break;
case 1:
retour_mbl ();
break;
case 2:
hold_question ();
ch_niv3 (2);
break;
default:
break;
}
break;
case '\0':
switch (next_hold ())
{
case 0:
ch_niv3 (1);
break;
case 1:
retour_mbl ();
break;
case 2:
hold_question ();
ch_niv3 (2);
break;
}
break;
case 'Q':
retour_mbl ();
break;
default:
hold_question ();
break;
}
break;
case 3:
switch (read_hold (1))
{
case 0:
pvoie->sr_mem = 0;
hold_question ();
ch_niv3 (2);
break;
case -1:
retour_mbl ();
break;
}
break;
default:
fbb_error (ERR_NIVEAU, "REVIEW", pvoie->niv3);
}
return (error);
}
fbb-7.0.11/src/epurmess.c 0000664 0001750 0001750 00000105005 13747456371 012074 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
#define ENGLISH
#include
#include
#include
#include
#include
#include
#include
#include
#ifdef __linux__
#include
#else
#include
#include
#include
#include
#endif
#include
#include
#define DEBUG 1
#define TRUE 1
#define FALSE 0
#ifdef ENGLISH
#define EXPI "Expi"
#define ARCH "Arch"
#define LECT "Read"
#define SUPP "Kill"
#define DETR "Dest"
#else
#define EXPI "Expi"
#define ARCH "Arch"
#define LECT "Lect"
#define SUPP "Supp"
#define DETR "Detr"
#endif
#ifdef __linux__
#define _read read
#define _write write
#define O_BINARY 0
#define __a2__ __attribute__ ((packed, aligned(2)))
#define stricmp strcasecmp
#define strcmpi strcasecmp
#define strnicmp strncasecmp
#define strncmpi strncasecmp
#else
#define __a2__
#endif
char cdate[80];
long numtot, numenr, nomess, numsup, numarc, nbtot;
long nbp, nbb;
char mycall[7], expediteur[7], destinataire[7];
char mypath[80];
long mdate;
#define MAX_RENUM (14L * 0x10000L)
#define DEL_RENUM (MAX_RENUM - 0x20000L)
#define NBBBS 80
#define NBMASK NBBBS/8
#define LGFREE 5
typedef struct
{ /* Longueur = 194 octets */
char type;
char status;
long numero __a2__;
long taille __a2__;
long date __a2__;
char bbsf[7];
char bbsv[41];
char exped[7];
char desti[7];
char bid[13];
char titre[61];
char bin;
char free[5];
long grpnum __a2__;
unsigned short nblu;
long theme __a2__;
long datesd __a2__;
long datech __a2__;
char fbbs[NBMASK];
char forw[NBMASK];
}
bullist;
typedef struct typ_serlist
{
char nom[7];
char delai;
struct typ_serlist *suiv;
}
deslist;
typedef struct
{
long pn;
long py;
long pf;
long px;
long pk;
long bn;
long by;
long bf;
long bx;
long bk;
long bd;
long rt;
long rr;
}
param;
#define BUFFSIZE 257
#define NB_AUTOMESS 2
int auto_mess[NB_AUTOMESS];
char text_rt[NB_AUTOMESS][BUFFSIZE];
char *mail_in;
char *callsign;
int nb_return_lines;
void aff_status (bullist *);
void change_defauts (param *, bullist *);
int copy_ (char *, char *);
void defauts (void);
void ent_arch (FILE *, bullist *);
void entete_liste (void);
void erreur_arg (int);
void init_liste (char *, int);
void message_retour (int, bullist *, long);
void newname (char *, char *);
void print_compte_rendu (void);
void print_zone(void);
char *date_mbl_new (long);
char *strdt (long);
int semaine (void);
int is_route (char *fbbs);
deslist *tete_exped, *tete_route, *tete_desti;
int *tabrec;
char *dirmes_sys;
char *dirmes_old;
char *dirmes_new;
char *compte_rendu;
char *old_mail;
char *mail;
char *binmail;
int archive_p, archive_b;
int old_format;
int ext_call = 0;
long heure;
param max, def;
FILE *fptr, *dptr;
extern long timezone;
#ifdef __linux__
char *strupr (char *str)
{
char *tmp = str;
while (*tmp)
{
if (islower (*tmp))
*tmp = toupper (*tmp);
++tmp;
}
return str;
}
char *back2slash (char *str)
{
char *tmp = str;
while (*tmp)
{
if (isupper (*tmp))
*tmp = tolower (*tmp);
if (*tmp == '\\')
*tmp = '/';
++tmp;
}
return str;
}
#endif
char *test_back_slash (char *chaine)
{
static char temp[256];
strcpy(temp, chaine);
if ((strlen(temp) == 0)
#ifdef __linux__
|| (temp[strlen (temp) - 1] != '/'))
strcat(temp, "/");
#else
|| (temp[strlen (temp) - 1] != '\\'))
strcat(temp, "\\");
#endif
return (temp);
}
void err_keyword(char *keyword)
{
fprintf(stderr, "Error : keyword \"%s\" missing in fbb.conf file\n", keyword);
exit(1);
}
void epure (char *ligne)
{
int lg;
lg = strlen (ligne);
if (ligne[lg - 1] == '\n')
ligne[lg - 1] = '\0';
lg = strlen (ligne);
if (ligne[lg - 1] == '\r')
ligne[lg - 1] = '\0';
if (*ligne == '\032')
*ligne = '\0';
}
static int fbb_unlink (char *filename)
{
int ret = unlink (filename);
return (ret);
}
int main (int ac, char **av)
{
int i;
char *s;
char *old_name;
char *new_name;
char *bin_name;
char *buffer;
int ecrit, unite;
bullist entete;
long record;
FILE *fcr, *fpti, *fpto;
long minimum;
long maximum;
int renum = 0;
mail_in = (char *) (calloc(80 , sizeof(char)));
callsign = (char *) (calloc(40 , sizeof(char)));
s = (char *) (calloc(BUFFSIZE , sizeof(char)));
old_name = (char *) (calloc(BUFFSIZE , sizeof(char)));
new_name = (char *) (calloc(BUFFSIZE , sizeof(char)));
bin_name = (char *) (calloc(BUFFSIZE , sizeof(char)));
buffer = (char *) (calloc(BUFFSIZE , sizeof(char)));
dirmes_sys = (char *) (calloc(BUFFSIZE , sizeof(char)));
dirmes_old = (char *) (calloc(BUFFSIZE , sizeof(char)));
dirmes_new = (char *) (calloc(BUFFSIZE , sizeof(char)));
compte_rendu = (char *) (calloc(BUFFSIZE , sizeof(char)));
old_mail = (char *) (calloc(BUFFSIZE , sizeof(char)));
mail = (char *) (calloc(BUFFSIZE , sizeof(char)));
binmail = (char *) (calloc(BUFFSIZE , sizeof(char)));
old_format = 0;
tete_exped = tete_route = tete_desti = NULL;
for (i = 0; i < NB_AUTOMESS; i++)
auto_mess[i] = 0;
printf ("Epurmess V%s\n\n", VERSION);
for (i = 1; i < ac; i++)
{
if (strnicmp ("/O", av[i], 2) == 0)
{
old_format = 1;
printf ("Archive in old format\n");
}
}
defauts ();
if (access (dirmes_sys, 0))
{
fprintf (stderr, "Cannot find %s\n", dirmes_sys);
exit (0);
}
heure = time (NULL);
minimum = heure - (10L * 12L * 30L * 24L * 3600L);
maximum = heure + (10L * 12L * 30L * 24L * 3600L);
if ((fcr = fopen (compte_rendu, "rt")) != NULL)
{
if (fread (s, 80, 1, fcr))
{
fclose (fcr);
/* if ((heure - atol (s)) > 864000L)
{
fcr = fopen (compte_rendu, "wt");
#ifdef ENGLISH
fprintf (fcr, "0\n\n");
fprintf (fcr, "EPURMESS was not done because your last EPURMESS was done more than 24h ago. \n\n");
fprintf (fcr, "Please verify the system clock!!!\n\n");
fprintf (fcr, "Kill this file (%s) to validate EPURMESS. \n", compte_rendu);
printf ("Last update > 24h. EPURMESS was not done. \n");
#else
fprintf (fcr, "0\n\n");
fprintf (fcr, "EPURMESS n'a pas ‚t‚ valid‚ car la derniŠre mise a jour remonte … plus de 24h.\n\n");
fprintf (fcr, "V‚rifiez votre horloge !!! \n\n");
fprintf (fcr, "Supprimer ce fichier (%s) pour revalider EPURMESS.\n", compte_rendu);
printf ("Date de derniŠre mise … jour > 24h. EPURMESS non effectu‚.\n");
#endif
fclose (fcr);
exit (1);
}
}
else
fclose (fcr);
*/
}
}
#ifdef ENGLISH
printf ("%s - Saves dirmes.sys file into dirmes.old file \n\n", date_mbl_new (time (NULL)));
#else
printf ("%s - Sauvegarde du fichier dirmes.sys en dirmes.old\n\n", date_mbl_new (time (NULL)));
#endif
if (!copy_ (dirmes_sys, dirmes_old))
{
#ifdef ENGLISH
printf ("%s - Cannot save dirmes.sys file into dirmes.old file !! \n\n", date_mbl_new (time (NULL)));
#else
printf ("%s - Sauvegarde du fichier dirmes.sys en dirmes.old impossible !!\n\n", date_mbl_new (time (NULL)));
#endif
}
if ((fptr = fopen (dirmes_sys, "rb")) == NULL)
{
#ifdef ENGLISH
printf ("Cannot open '%s' \n", dirmes_sys);
#else
printf ("Erreur ouverture '%s'\n", dirmes_sys);
#endif
exit (1);
}
if ((dptr = fopen (dirmes_new, "wb")) == NULL)
{
exit (1);
}
nbp = nbb = numtot = numenr = numsup = numarc = 0L;
entete_liste ();
if (fread (&entete, sizeof (bullist), 1, fptr) == 0)
{
#ifdef ENGLISH
printf ("Error while reading file '%s'\n", dirmes_sys);
#else
printf ("Erreur lecture fichier '%s' \n", dirmes_sys);
#endif
exit (1);
}
if (entete.numero > MAX_RENUM)
{
renum = 1;
entete.numero -= DEL_RENUM;
}
if (fwrite (&entete, sizeof (bullist), 1, dptr) == 0)
{
#ifdef ENGLISH
printf ("Error while writing file '%s'\n", dirmes_new);
#else
printf ("Erreur ecriture fichier '%s' \n", dirmes_new);
#endif
exit (1);
}
record = 1L;
strncpy (mycall, entete.exped, sizeof (mycall));
while (1)
{
ecrit = 1;
if (fread (&entete, sizeof (bullist), 1, fptr) == 0)
break;
entete.bbsf[6] = '\0';
entete.bbsv[40] = '\0';
entete.exped[6] = '\0';
entete.desti[6] = '\0';
entete.bid[12] = '\0';
entete.titre[60] = '\0';
if (renum)
{
if ((entete.numero - DEL_RENUM) < 1L)
{
entete.status = 'A';
}
}
memset (entete.free, '\0', LGFREE);
unite = (unsigned int) (entete.numero % 10);
if (entete.type == '\0')
{
#ifdef __linux__
sprintf (old_name, "%smail%d/m_%06ld.mes", mail, unite, entete.numero);
sprintf (bin_name, "%smail%d/m_%06ld.mes", binmail, unite, entete.numero);
#else
sprintf (old_name, "%sMAIL%d\\M_%06ld.MES", mail, unite, entete.numero);
sprintf (bin_name, "%sMAIL%d\\M_%06ld.MES", binmail, unite, entete.numero);
#endif
fbb_unlink (old_name);
fbb_unlink (bin_name);
continue;
}
aff_status (&entete);
def = max;
change_defauts (&def, &entete);
if ((entete.datech < minimum) || (entete.datech > maximum))
entete.status = 'A';
if ((entete.date < minimum) || (entete.date > maximum))
entete.status = 'A';
if ((entete.datesd < minimum) || (entete.datesd > maximum))
entete.datesd = entete.date;
/* Message erronne */
if ((entete.taille > 10000000L) || (entete.taille < 0))
entete.status = 'A';
if (entete.datech > heure)
entete.datech = heure;
if (entete.date > heure)
entete.date = heure;
#ifdef __linux__
sprintf (old_name, "%smail%d/m_%06ld.mes", mail, unite, entete.numero);
sprintf (bin_name, "%smail%d/m_%06ld.mes", binmail, unite, entete.numero);
#else
sprintf (old_name, "%sMAIL%d\\M_%06ld.MES", mail, unite, entete.numero);
sprintf (bin_name, "%sMAIL%d\\M_%06ld.MES", binmail, unite, entete.numero);
#endif
if ((entete.type == 'P') && (entete.status == 'N') && (*entete.bbsv))
{
if (!is_route (entete.fbbs) && (def.rr) && (heure - entete.date >= def.rr))
{
message_retour (1, &entete, heure);
entete.status = 'A';
}
else if (!is_route (entete.forw) && (def.rt) && (heure - entete.date >= def.rt))
{
message_retour (0, &entete, heure);
entete.status = 'A';
}
}
if ((entete.type == 'A') && (entete.status != 'N'))
{
/* Destruction immediate */
printf (DETR);
fbb_unlink (old_name);
fbb_unlink (bin_name);
++numsup;
ecrit = 0;
}
else if ((entete.type == 'P') || (entete.type == 'A'))
{
if ((entete.status == '$') && (heure - entete.datech >= def.bd))
{
entete.status = 'X';
entete.datech = heure;
fbb_unlink (bin_name);
printf (EXPI);
}
if ((entete.status == 'N') && (heure - entete.datech >= def.pn))
{
entete.status = 'X';
entete.datech = heure;
fbb_unlink (bin_name);
printf (EXPI);
}
if ((entete.status == 'Y') && (heure - entete.datech >= def.py))
{
entete.status = 'X';
entete.datech = heure;
fbb_unlink (bin_name);
printf (EXPI);
}
if ((entete.status == 'F') && (heure - entete.datech >= def.pf))
{
entete.status = 'K';
entete.datech = heure;
fbb_unlink (bin_name);
printf (SUPP);
}
if ((entete.status == 'X') && (heure - entete.datech >= def.px))
{
entete.status = 'K';
entete.datech = heure;
fbb_unlink (bin_name);
printf (SUPP);
}
if ((entete.status == 'K') && (heure - entete.datech >= def.pk))
{
entete.status = 'A';
entete.datech = heure;
}
if (entete.status == 'A')
{
/* Archivage immediat */
fbb_unlink (bin_name);
if (archive_p)
{
sprintf (new_name, "%sPRIV.%02d", old_mail, semaine ());
if ((fpto = fopen (new_name, "at")) != NULL)
{
ent_arch (fpto, &entete);
if ((fpti = fopen (old_name, "rt")) != NULL)
{
while (fgets (buffer, 256, fpti))
{
fputs (buffer, fpto);
}
fclose (fpti);
}
fprintf (fpto, "\n/EX\n");
fclose (fpto);
}
printf (ARCH);
++numarc;
}
else
{
printf (DETR);
++numsup;
}
fbb_unlink (old_name);
ecrit = 0;
}
if (ecrit)
++nbp;
}
else
{
if ((entete.status == 'N') && (heure - entete.datech >= def.bn))
{
entete.status = 'X';
entete.datech = heure;
fbb_unlink (bin_name);
printf (EXPI);
}
if ((entete.status == '$') && (heure - entete.datech >= def.bd))
{
entete.status = 'X';
entete.datech = heure;
fbb_unlink (bin_name);
printf (EXPI);
}
if ((entete.status == 'Y') && (heure - entete.datech >= def.by))
{
entete.status = 'X';
entete.datech = heure;
fbb_unlink (bin_name);
printf (EXPI);
}
if ((entete.status == 'F') && (heure - entete.datech >= def.bf))
{
entete.status = 'K';
entete.datech = heure;
fbb_unlink (bin_name);
printf (SUPP);
}
if ((entete.status == 'X') && (heure - entete.datech >= def.bx))
{
entete.status = 'K';
entete.datech = heure;
fbb_unlink (bin_name);
printf (SUPP);
}
if ((entete.status == 'K') && (heure - entete.datech >= def.bk))
{
entete.status = 'A';
entete.datech = heure;
}
if (entete.status == 'A')
{
/* Archivage immediat */
fbb_unlink (bin_name);
if (archive_b)
{
sprintf (new_name, "%sBULL.%02d", old_mail, semaine ());
if ((fpto = fopen (new_name, "at")) != NULL)
{
ent_arch (fpto, &entete);
if ((fpti = fopen (old_name, "rt")) != NULL)
{
while (fgets (buffer, 256, fpti))
fputs (buffer, fpto);
fclose (fpti);
}
fprintf (fpto, "\n/EX\n");
fclose (fpto);
}
printf (ARCH);
++numarc;
}
else
{
printf (DETR);
++numsup;
}
fbb_unlink (old_name);
ecrit = 0;
}
if (ecrit)
++nbb;
}
if (ecrit)
{
++numtot;
if (entete.status != 'K')
++numenr;
++record;
}
if (ecrit)
{
if (renum)
{
char ren_name[257];
entete.numero -= DEL_RENUM;
unite = (unsigned int) (entete.numero % 10);
#ifdef __linux__
sprintf (ren_name, "%smail%d/m_%06ld.mes", mail, unite, entete.numero);
#else
sprintf (ren_name, "%sMAIL%d\\M_%06ld.MES", mail, unite, entete.numero);
#endif
/* delete the binary file */
unlink (bin_name);
/* rename the ascii file */
newname (old_name, ren_name);
}
if (fwrite (&entete, sizeof (bullist), 1, dptr) == 0)
{
#ifdef ENGLISH
printf ("Error while writing file '%s'\n", dirmes_old);
#else
printf ("Erreur ecriture fichier '%s' \n", dirmes_old);
#endif
exit (1);
}
}
putchar ('\n');
}
putchar ('\n');
fclose (dptr);
fclose (fptr);
#ifdef ENGLISH
printf ("Saves into dirmes.old - Copies dirmes.new into dirmes.sys \n");
#else
printf ("Sauvegarde dans dirmes.old - Recopie dirmes.new dans dirmes.sys\n");
#endif
if (!copy_ (dirmes_new, dirmes_sys))
{
#ifdef ENGLISH
printf ("%s - Cannot save dirmes.new file into dirmes.sys file !! \n\n", date_mbl_new (time (NULL)));
#else
printf ("%s - Sauvegarde du fichier dirmes.new en dirmes.sys impossible !!\n\n", date_mbl_new (time (NULL)));
#endif
}
print_compte_rendu ();
return (0);
}
void print_compte_rendu ()
{
FILE *fcr;
#ifdef ENGLISH
printf ("\n");
printf ("File cleared : %4ld private message(s) \n", nbp);
printf (" : %4ld bulletin message(s) \n", nbb);
printf (" : %4ld active message(s) \n", numenr);
printf (" : %4ld killed message(s) \n", numtot - numenr);
printf (" : %4ld total message(s) \n", numtot);
printf (" : %4ld archived message(s) \n", numarc);
printf (" : %4ld destroyed message(s) \n", numsup);
printf (" : %4d Timed-out message(s) \n", auto_mess[0]);
printf (" : %4d No-Route message(s) \n\n", auto_mess[1]);
if ((fcr = fopen (compte_rendu, "wt")) != NULL)
{
fprintf (fcr, "%ld\n\n", heure);
fprintf (fcr, "File cleared : %4ld private message(s) \n", nbp);
fprintf (fcr, " : %4ld bulletin message(s) \n", nbb);
fprintf (fcr, " : %4ld active message(s) \n", numenr);
fprintf (fcr, " : %4ld killed message(s) \n", numtot - numenr);
fprintf (fcr, " : %4ld total message(s) \n", numtot);
fprintf (fcr, " : %4ld archived message(s) \n", numarc);
fprintf (fcr, " : %4ld destroyed message(s) \n", numsup);
fprintf (fcr, " : %4d Timed-out message(s) \n", auto_mess[0]);
fprintf (fcr, " : %4d No-Route message(s) \n\n", auto_mess[1]);
fprintf (fcr, "Start computing : %s\n", strdt (heure));
fprintf (fcr, "End computing : %s\n", strdt (time (NULL)));
fclose (fcr);
}
#else
printf ("\n");
printf ("Fichier ‚pur‚ : %4ld message(s) priv‚(s) \n", nbp);
printf (" : %4ld message(s) bulletin(s)\n", nbb);
printf (" : %4ld message(s) actif(s) \n", numenr);
printf (" : %4ld message(s) supprim‚(s)\n", numtot - numenr);
printf (" : %4ld message(s) total \n", numtot);
printf (" : %4ld message(s) archiv‚(s) \n", numarc);
printf (" : %4ld message(s) d‚truit(s) \n", numsup);
printf (" : %4d message(s) oubli‚(s) \n", auto_mess[0]);
printf (" : %4d message(s) sans route \n\n", auto_mess[1]);
if (fcr = fopen (compte_rendu, "wt"))
{
fprintf (fcr, "%ld\n\n", heure);
fprintf (fcr, "Fichier ‚pur‚ : %4ld message(s) priv‚(s) \n", nbp);
fprintf (fcr, " : %4ld message(s) bulletin(s)\n", nbb);
fprintf (fcr, " : %4ld message(s) actif(s) \n", numenr);
fprintf (fcr, " : %4ld message(s) supprim‚(s)\n", numtot - numenr);
fprintf (fcr, " : %4ld message(s) total \n", numtot);
fprintf (fcr, " : %4ld message(s) archiv‚(s) \n", numarc);
fprintf (fcr, " : %4ld message(s) d‚truit(s) \n", numsup);
fprintf (fcr, " : %4d message(s) oubli‚(s) \n", auto_mess[0]);
fprintf (fcr, " : %4d message(s) sans route \n\n", auto_mess[1]);
fprintf (fcr, "Debut du traitement : %s\n", strdt (heure));
fprintf (fcr, "Fin du traitement : %s\n", strdt (time (NULL)));
fclose (fcr);
}
#endif
}
void change_defauts (param * def, bullist * bull)
{
deslist *lptr;
lptr = tete_exped;
while (lptr)
{
if (strcmp (lptr->nom, bull->exped) == 0)
{
def->bf = def->bx = def->pf = def->px = (long) lptr->delai * 86400L;
break;
}
lptr = lptr->suiv;
}
lptr = tete_route;
while (lptr)
{
if (strcmp (lptr->nom, bull->bbsv) == 0)
{
def->bf = def->bx = def->pf = def->px = (long) lptr->delai * 86400L;
break;
}
lptr = lptr->suiv;
}
lptr = tete_desti;
while (lptr)
{
if (strcmp (lptr->nom, bull->desti) == 0)
{
def->bf = def->bx = def->pf = def->px = (long) lptr->delai * 86400L;
break;
}
lptr = lptr->suiv;
}
}
void entete_liste (void)
{
#ifdef ENGLISH
printf ("Act Msg# TS Dim. To @ BBS From Date Datexp Subject\n");
#else
printf ("Act Msg# TS Dim. Pour @ BBS Exp. Date Datexp Sujet \n");
#endif
}
char *bbs_via (char *s)
{
int nb = 0;
static char bbs[80];
while ((*s) && (*s != '.'))
{
if (nb == 6)
break;
bbs[nb++] = *s++;
}
bbs[nb] = '\0';
return (bbs);
}
void aff_status (bullist * ligne)
{
int i;
char *ptri, *ptro;
char bbs_v[42], date[40], datech[40], titre[21];
if (*(ligne->bbsv))
sprintf (bbs_v, "@%-6s", bbs_via (ligne->bbsv));
else
*bbs_v = '\0';
strcpy (datech, date_mbl_new (ligne->datech));
strcpy (date, date_mbl_new (ligne->date));
ptri = ligne->titre;
ptro = titre;
for (i = 0; i < 20; i++)
{
if (*ptri == '\0')
break;
if (*ptri == '\a')
*ptro = ' ';
else
*ptro = *ptri;
++ptri;
++ptro;
}
*ptro = '\0';
#ifdef ENGLISH
printf ("Read %6ld %c%c %5ld %-6s%7s %-6s %-6s %s %1.19s\r",
ligne->numero, ligne->type, ligne->status,
ligne->taille, ligne->desti, bbs_v, ligne->exped,
date, datech, titre);
#else
printf ("Lect %6ld %c%c %5ld %-6s%7s %-6s %-6s %s %1.19s\r",
ligne->numero, ligne->type, ligne->status,
ligne->taille, ligne->desti, bbs_v, ligne->exped,
date, datech, titre);
#endif
}
int find (char *s)
{
char *t = s;
int n = 0;
int dernier = 0, chiffre = 0, lettre = 0;
while (*t)
{
if (!isalnum (*t))
return (FALSE);
*t = toupper (*t);
dernier = (isdigit (*t));
if (isdigit (*t))
++chiffre;
else
++lettre;
++t;
++n;
}
if (ext_call)
{
/*
* 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 (0);
}
else
{
/*
* L'indicatif doit avoir entre 3 et 6 caracteres .
* doit contenir 1 ou 2 chiffres .
* ne doit pas se terminer par un chiffre .
*/
if ((n < 3) || (n > 6) || (chiffre < 1) || (chiffre > 2) || dernier)
return (0);
}
return (1);
}
char *date_mbl_new (long temps)
{
struct tm *sdate;
static char cdate[40];
sdate = localtime (&temps);
#ifdef ENGLISH
sprintf (cdate, "%02d-%02d-%02d", sdate->tm_year % 100, sdate->tm_mon + 1, sdate->tm_mday);
#else
sprintf (cdate, "%02d/%02d/%02d", sdate->tm_mday, sdate->tm_mon + 1, sdate->tm_year % 100);
#endif
return (cdate);
}
char *strdt (long temps)
{
struct tm *sdate;
static char cdate[80];
sdate = localtime (&temps);
#ifdef ENGLISH
sprintf (cdate, "%02d-%02d-%02d %02d:%02d",
sdate->tm_year % 100,
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 % 100,
sdate->tm_hour,
sdate->tm_min);
#endif
return (cdate);
}
void print_zone()
{
char *tz;
printf( "TZ: %s ", (tz = getenv( "TZ" )) ? tz : "not set" );
printf( "- daylight: %d ", daylight );
printf( "- timezone: %ld ", timezone );
printf( "- time zone names: %s %s\n",
tzname[0], tzname[1] );
}
void defauts (void)
{
int i;
unsigned int flag;
int init = 1;
int nolig, lig;
FILE *fptr;
char *c_path;
char *ligne;
char *str;
static char *tzlig;
char *ptr;
char *temp;
c_path = (char *) (calloc(BUFFSIZE , sizeof(char)));
ligne = (char *) (calloc(BUFFSIZE , sizeof(char)));
str = (char *) (calloc(80 , sizeof(char)));
tzlig = (char *) (calloc(80 , sizeof(char)));
temp = (char *) (calloc(20 , sizeof(char)));
if (read_fbb_conf(NULL) > 0)
{
#ifdef ENGLISH
fprintf (stderr, "Cannot open fbb.conf file \n");
#else
fprintf (stderr, "Erreur ouverture fichier fbb.conf\n");
#endif
exit (1); /* and users base directory */
}
ptr = find_fbb_conf("vers", 0);
if (ptr == NULL)
{
#ifdef ENGLISH
fprintf (stderr, "Version number missing in fbb.conf\n");
#else
fprintf (stderr, "Pas de numéro dans le fbb.conf\n");
#endif
exit (1);
}
sprintf (temp, "FBB%s", VERSION);
/* Only test the major number ... */
if (strncasecmp (temp, ptr, 4) != 0)
{
#ifdef ENGLISH
fprintf (stderr, "Wrong version number in fbb.conf\n");
#else
fprintf (stderr, "Numéro de version erroné dans fbb.conf\n");
#endif
exit (1);
}
#ifdef __linux__
fprintf (stderr, "Configuration version : %s\n", ptr);
#else
fprintf (stderr, "Configuration version : %s\r", ptr);
#endif
ptr = find_fbb_conf("call", 0);
if (ptr == NULL)
err_keyword("call");
strcpy (callsign, strupr (ptr));
strcpy (mypath, strupr (ptr));
if ((ptr = strchr (callsign, '.')) != NULL)
*ptr = '\0';
#ifdef ENGLISH
fprintf (stderr, "Callsign : %s\n", callsign);
fprintf (stderr, "Address : %s\n", mypath);
#else
fprintf (stderr, "Indicatif : %s\n", callsign);
fprintf (stderr, "Addresse : %s\n", mypath);
#endif
/* Mail.in */
ptr = find_fbb_conf("impo", 0);
if (ptr == NULL)
ptr = def_fbb_conf("impo");
if (ptr == NULL)
err_keyword("impo");
strcpy (mail_in, strupr (ptr));
#ifdef __linux__
back2slash (mail_in);
#endif
#ifdef ENGLISH
fprintf (stderr, "MAIL.IN file : %s\n", mail_in);
#else
fprintf (stderr, "fichier MAIL.IN: %s\n", mail_in);
#endif
/* path of conf files */
ptr = find_fbb_conf("conf", 0);
if (ptr == NULL)
ptr = def_fbb_conf("conf");
if (ptr == NULL)
err_keyword("conf");
strcpy (c_path, test_back_slash(ptr));
#ifdef ENGLISH
fprintf (stderr, "Conf directory : %s\n", c_path);
#else
fprintf (stderr, "Configuration : %s\n", c_path);
#endif
/* flags */
ptr = find_fbb_conf("fbbf", 0);
if (ptr == NULL)
ptr = def_fbb_conf("fbbf");
if (ptr == NULL)
err_keyword("fbbf");
flag = 0;
sscanf (ptr, "%s %u", str, &flag);
ext_call = ((flag & 4096) != 0);
/* diff GMT */
ptr = find_fbb_conf("loca", 0);
if (ptr == NULL)
ptr = def_fbb_conf("loca");
if (ptr == NULL)
err_keyword("loca");
#ifdef ENGLISH
fprintf (stderr, "GMT difference : %d - ", atoi (ptr));
#else
fprintf (stderr, "Diff‚rence GMT : %d - ", atoi (ptr));
#endif
tzset (); /* get timezone info */
print_zone();
putchar ('\n');
sleep (2);
lig = nolig = 0;
sprintf(ligne, "%sepurmess.ini", c_path);
#ifdef __linux__
if ((fptr = fopen (ligne, "r")) != NULL)
#else
if ((fptr = fopen (ligne, "rt")) != NULL)
#endif
{
while (fgets (ligne, 256, fptr))
{
epure (ligne);
nolig++;
if ((*ligne == '#') || (*ligne == '\0') || (*ligne == '\032'))
continue;
lig++;
if ((lig < 20) && (lig > 21))
strupr (ligne);
if (init)
{
switch (lig)
{
case 1:
strcpy (mail, ligne);
#ifdef __linux__
back2slash (mail);
#endif
break;
case 2:
strcpy (binmail, ligne);
#ifdef __linux__
back2slash (binmail);
#endif
break;
case 3:
strcpy (old_mail, ligne);
#ifdef __linux__
back2slash (old_mail);
#endif
break;
case 4:
strcpy (dirmes_sys, ligne);
#ifdef __linux__
back2slash (dirmes_sys);
#endif
break;
case 5:
strcpy (dirmes_old, ligne);
#ifdef __linux__
back2slash (dirmes_old);
#endif
break;
case 6:
strcpy (dirmes_new, ligne);
#ifdef __linux__
back2slash (dirmes_new);
#endif
break;
case 7:
strcpy (compte_rendu, ligne);
#ifdef __linux__
back2slash (compte_rendu);
#endif
break;
case 8:
archive_p = archive_b = 1;
sscanf (ligne, "%d %d", &archive_p, &archive_b);
break;
case 9:
max.pn = atol (ligne) * 86400L;
break;
case 10:
max.py = atol (ligne) * 86400L;
break;
case 11:
max.pf = atol (ligne) * 86400L;
break;
case 12:
max.px = atol (ligne) * 86400L;
break;
case 13:
max.pk = atol (ligne) * 86400L;
break;
case 14:
max.bn = atol (ligne) * 86400L;
break;
case 15:
max.bd = atol (ligne) * 86400L;
break;
case 16:
max.by = atol (ligne) * 86400L;
break;
case 17:
max.bx = atol (ligne) * 86400L;
break;
case 18:
max.bf = atol (ligne) * 86400L;
break;
case 19:
max.bk = atol (ligne) * 86400L;
break;
case 20:
sscanf (ligne, "%ld %[^\n]", &max.rt, text_rt[0]);
if (max.rt == 0)
*text_rt[0] = '\0';
max.rt *= 86400L;
break;
case 21:
sscanf (ligne, "%ld %[^\n]", &max.rr, text_rt[1]);
if (max.rr == 0)
*text_rt[1] = '\0';
max.rr *= 86400L;
break;
case 22:
nb_return_lines = atoi (ligne);
break;
case 23:
if (*ligne != '-')
erreur_arg (nolig);
init = 0;
break;
default:
erreur_arg (nolig);
break;
}
}
else
{
if (*ligne == '-')
break;
init_liste (ligne, nolig);
}
}
for (i = 0; i < NB_AUTOMESS; i++)
{
char *ptri;
char *ptro;
ptri = ptro = text_rt[i];
while (*ptri)
{
if ((*ptri == '$') && (*(ptri + 1) == 'W'))
{
*ptro = '\n';
++ptri;
}
else
*ptro = *ptri;
++ptri;
++ptro;
}
*ptro = '\0';
}
}
else
{
#ifdef ENGLISH
fprintf (stderr, "Cannot open EPURMESS.INI file \n");
#else
fprintf (stderr, "Erreur ouverture fichier EPURMESS.INI\n");
#endif
exit (1);
}
}
void init_liste (char *ligne, int nolig)
{
char *nom;
int temps;
int init = 0;
char *mode;
deslist *lptr = tete_desti;
nom = (char *) (calloc(80 , sizeof(char)));
mode = (char *) (calloc(80 , sizeof(char)));
if (sscanf (ligne, "%s %s %d", mode, nom, &temps) != 3)
erreur_arg (nolig);
switch (toupper (*mode))
{
case 'F':
case '<':
lptr = tete_exped;
if (lptr == NULL)
{
tete_exped = lptr = malloc (sizeof (deslist));
init = 1;
}
break;
case 'V':
case '@':
lptr = tete_route;
if (lptr == NULL)
{
tete_route = lptr = malloc (sizeof (deslist));
init = 1;
}
break;
case 'T':
case '>':
lptr = tete_desti;
if (lptr == NULL)
{
tete_desti = lptr = malloc (sizeof (deslist));
init = 1;
}
break;
default:
erreur_arg (nolig);
break;
}
if (init == 0)
{
while (lptr->suiv)
lptr = lptr->suiv;
lptr->suiv = malloc (sizeof (deslist));
lptr = lptr->suiv;
}
lptr->suiv = NULL;
strncpy (lptr->nom, nom, 6);
lptr->nom[6] = '\0';
lptr->delai = temps;
}
#if 0
void copy_ (char *oldfich, char *newfich)
{
char s[256];
#ifdef __linux__
sprintf (s, "cp %s %s > /dev/null", oldfich, newfich);
#else
sprintf (s, "copy %s %s", oldfich, newfich);
#endif
system (s);
}
#endif
#define TAIBUF 16384
/* static char buffer[TAIBUF]; */
int copy_ (char *oldfich, char *newfich)
{
int retour = 1;
int fd_orig;
int fd_dest;
int nb_lus;
int ret;
int dest_access;
char *buffer;
buffer = (char *) (calloc(TAIBUF , sizeof(char)));
if (buffer == NULL) {
fprintf (stderr, "Not enough memory for epurmess file copy function\n");
return (0);
}
if ((fd_orig = open (oldfich, O_RDONLY | O_BINARY, S_IREAD | S_IWRITE)) == EOF)
{
fprintf (stderr, "Cannot find %s\n", oldfich);
free (buffer);
return (0);
}
dest_access = O_WRONLY | O_CREAT | O_TRUNC | O_BINARY;
if ((fd_dest = open (newfich, dest_access, S_IREAD | S_IWRITE)) == EOF)
{
close (fd_orig);
fprintf (stderr, "Cannot create %s\n", newfich);
free (buffer);
return (0);
}
for (;;)
{
nb_lus = _read (fd_orig, buffer, TAIBUF);
if (nb_lus == -1)
{
retour = 0;
break;
}
if (nb_lus == 0)
{
retour = 1;
break;
}
ret = _write (fd_dest, buffer, nb_lus);
if (ret != nb_lus)
{
retour = 0;
break;
}
}
close (fd_orig);
close (fd_dest);
free (buffer);
return (retour);
}
void newname (char *oldfich, char *newfich)
{
rename (oldfich, newfich);
}
int is_route (char *fbbs)
{
int i;
for (i = 0; i < NBMASK; i++)
if (fbbs[i])
return (1);
return (0);
}
void erreur_arg (int numero)
{
#ifdef ENGLISH
printf ("Error EPURMESS.INI in line Nb %d \n", numero);
#else
printf ("Erreur fichier EPURMESS.INI ligne Nø%d\n", numero);
#endif
exit (1);
}
int semaine (void)
{
long temps = time (NULL);
struct tm *sdate = localtime (&temps);
#if 0
int ny = sdate->tm_yday - 1;
int nw = sdate->tm_wday;
int first_day;
if (nw == 0)
nw = 6;
else
--nw;
if (ny <= nw)
first_day = nw - ny;
else
first_day = 7 - ((ny - nw) % 7);
return ((((ny + first_day) / 7) % 52) + 1);
#endif
int ny = sdate->tm_yday; /* Numero du jour dans l'annee */
int nw = sdate->tm_wday; /* Numero du jour dans la semaine */
if (nw == 0)
nw = 6;
else
--nw; /* 0 = dimanche -> 0 = lundi */
if (ny < nw) /* Premiere semaine de l'annee ? */
{
temps -= (3600L * 24L * (ny + 1));
sdate = localtime (&temps);
ny = sdate->tm_yday; /* Numero du jour de l'annee precedente */
nw = sdate->tm_wday; /* Numero du jour de la semaine avant */
if (nw == 0)
nw = 6;
else
--nw; /* 0 = dimanche -> 0 = lundi */
}
return ((7 - nw + ny) / 7);
}
void ent_arch (FILE * fptr, bullist * pm)
{
char *bbsv;
long temps = pm->date;
struct tm *sdate = gmtime (&temps);
bbsv = (char *) (calloc(80 , sizeof(char)));
if (old_format)
{
fprintf (fptr, "Msg #%ld Type:%c Stat:%c To:%s@%s From:%s Date:%s \n",
pm->numero, pm->type, pm->status, pm->desti,
pm->bbsv, pm->exped, strdt (pm->date));
fprintf (fptr, "Bid: %s Subject: %s\n", pm->bid, pm->titre);
}
else
{
if (*pm->bbsv)
sprintf (bbsv, " @ %s", pm->bbsv);
else
*bbsv = '\0';
fprintf (fptr, "S%c %s%s < %s $%s\n",
pm->type, pm->desti, bbsv, pm->exped, pm->bid);
fprintf (fptr, "%s\n", pm->titre);
}
fprintf (fptr, "R:%02d%02d%02d/%02d%02dZ @:%s\n",
sdate->tm_year % 100, sdate->tm_mon + 1, sdate->tm_mday,
sdate->tm_hour, sdate->tm_min, mypath);
}
void message_retour (int num_txt, bullist * entete, long heure)
{
FILE *mess;
FILE *fptr;
int unite;
int i;
int nrl;
char *bbs;
char *ligne;
char *scan;
ligne = (char *) (calloc(BUFFSIZE , sizeof(char)));
bbs = (char *) (calloc(42 , sizeof(char)));
/*
printf("\nDemande de message %d\n", num_txt);
printf("Message = <%s>\n", text_rt[num_txt]);
sleep(5);
*/
if (*text_rt[num_txt] == '\0')
return;
if (num_txt >= NB_AUTOMESS)
return;
nrl = nb_return_lines;
*bbs = '\0';
++auto_mess[num_txt];
unite = entete->numero % 10;
sprintf (ligne, "%sMAIL%d\\M_%06ld.MES", mail, unite, entete->numero);
if ((mess = fopen (ligne, "rt")) == NULL)
{
return;
}
while (fgets (ligne, 256, mess))
{
if (strncmp (ligne, "R:", 2) != 0)
break;
scan = ligne;
while ((*scan) && (*scan != '@'))
++scan;
++scan;
if (*scan == ':')
++scan;
i = 0;
while (isgraph (*scan))
{
bbs[i] = toupper (*scan);
++scan;
if (++i == 40)
break;
}
bbs[i] = '\0';
}
if (*bbs == '\0')
strcpy (bbs, callsign);
if ((fptr = fopen (mail_in, "at")) != NULL)
{
fprintf (fptr, "SP %s @ %s < %s\n", entete->exped, bbs, callsign);
fprintf (fptr, "Undelivered mail in %s\n\n", callsign);
fprintf (fptr, "%s BBS, %s%s",
callsign, ctime (&heure), text_rt[num_txt]);
fprintf (fptr, "\n\nSP %s @ %s < %s\n",
entete->desti, entete->bbsv, entete->exped);
fprintf (fptr, "%s\n", entete->titre);
while (fgets (ligne, 256, mess))
{
if (nrl-- <= 0)
break;
if (strncmpi (ligne, "/ACK", 4) != 0)
fputs (ligne, fptr);
}
fprintf (fptr, "/EX\n");
}
fclose (fptr);
fclose (mess);
}
fbb-7.0.11/src/pacsat.c 0000664 0001750 0001750 00000066623 13750012212 011470 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
/* pbdir.c 1993.8.6 */
/*#ifdef __linux__
#define __a1__ __attribute__ ((packed, aligned(1)))
#else */
#define __a1__
/*#endif*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define PFH_MSG 1
#define PFH_FILE 2
static BOOL f_beacon = OFF;
static struct stqueue actuser;
static struct stqueue freeuser;
static struct stqueue freehole;
static char rkss[FRMSIZE];
static ushort chck;
static ushort crc;
static struct stuser user[MAXUSER];
static struct sthole hole[MAXHOLE];
static long tim_0;
static long tim_1;
static long tim_2;
static long tim_3;
static int baud;
typedef struct full_sockaddr_ax25 fs_ax25;
static BOOL f_rkss; /* pbsv.c */
static int lnrkss;
static struct stpfhdir pfhdir[MAXPFHDIR];
static char pac_call[12];
static char pac_port[12];
static int npfhdir;
static int msock = -1; /* Rx monitoring socket */
static int pacsat;
static long to_empty;
static long to_user;
#ifdef PACDBG
static void dispdir (void);
#endif
static int add_buf (char *buf, void *data, int nb);
static uchar send_pfh (int dirent, int block_size);
static int req_dir (char *callsign);
static int pfhstat ( char *name, struct stpfh *pfh);
static void initq (struct stqueue *q);
static void putq (struct stqueue *q, struct stqcell *d);
static struct stqcell *getq (struct stqueue *q);
static void delq (struct stqueue *q, struct stqcell *d);
static void timer (void);
static void pblist (int ctl);
static void qst (void);
static void qst_dir (struct stuser *user);
static void qst_bul (struct stuser *user);
static void rcvreq (void);
static void res_msg (char *callsign, int errorcode);
static int findfile (int id);
static int compare (struct stpfhdir *d1, struct stpfhdir *d2);
static int req_bul (char *callsign);
static void set_user (struct stuser *user, char *callsign, long file_id, ushort block_size);
static void add_hole (struct stuser *user, long offset, ushort length);
static struct stuser *sch_user (char *callsign);
static void del_user (struct stuser *user);
static int add_struct (char *buf, int id, void *data, int lg_data);
static int pfh_msg (FILE * fpth, long numero);
static int mk_pfh (char *buf, bullist * pbul, long numero);
static int mk_pfh_file (long numero, int type);
static char *dlname (long numero);
static void rm_pfh_file (long numero);
static int add_crc (char *buf, int nb);
static void snd_pac (char *desti, char *buf, int len, int pid);
static int rcvkss (void);
static char *ax25_ntoaii (char *call);
/*
* ax25 -> ascii conversion
*/
static char *_ax25_ntoa(const ax25_address *a)
{
static char buf[11];
char c, *s;
int n;
for (n = 0, s = buf; n < 6; n++) {
c = (a->ax25_call[n] >> 1) & 0x7F;
if (c != ' ')
*s++ = c;
}
*s++ = '-';
n = (a->ax25_call[6] >> 1) & 0x0F;
if (n > 9) {
*s++ = '1';
n -= 10;
}
*s++ = n + '0';
*s++ = '\0';
return buf;
}
void pbsv (void)
{
if (pacsat == 0)
return;
timer ();
while (rcvkss ())
rcvreq ();
qst ();
pblist (0);
}
#define TIME(x) ((((long)(x)) << 16) / 3600L)
void init_pac (void)
{
FILE *fptr;
char buf[256];
char *av1, *av2;
if ((fptr = fopen ("init.pac", "r")) == NULL)
{
pacsat = 0;
/* removed warning until this protocol is used by future satellites ???
* printf ("No PACSAT satellit protocol configuration file 'init.pac'\n"); */
return;
}
printf ("Reading PACSAT satellite protocol configuration file 'init.pac'\n");
/* Default values */
strcpy (pac_call, mycall);
if (myssid)
{
sprintf (pac_call + strlen (pac_call), "-%d", myssid);
}
n_cpy (10, pac_port, p_port[1].name);
to_empty = TIME (2);
to_user = TIME (10);
baud = 1200;
while (fgets (buf, 128, fptr) != NULL)
{
av1 = strtok (buf, " \t\r\n");
strupr (av1);
if (av1 == NULL)
continue;
av2 = strtok (NULL, " \t\r\n");
if (av2 == NULL)
continue;
if (strcmp (av1, "CALLSIGN") == 0)
{
strupr (av2);
n_cpy (10, pac_call, av2);
}
else if (strcmp (av1, "PORT") == 0)
{
n_cpy (10, pac_port, av2);
}
else if (strcmp (av1, "USER") == 0)
{
to_user = TIME (atoi (av2));
printf ("User time-out = %s sec\n", av2);
}
else if (strcmp (av1, "EMPTY") == 0)
{
to_empty = TIME (atoi (av2));
printf ("PB empty time-out = %s sec\n", av2);
}
else if (strcmp (av1, "BAUD") == 0)
{
baud = atoi (av2);
printf ("Baud rate = %d\n", baud);
}
}
fclose (fptr);
printf ("Broadcast callsign [%s]\n", pac_call);
printf ("Broadcast port [%s]\n", pac_port);
pacsat = 1;
}
/*
* < initdir > initialize directory entry
* Opens dirmes.sys and initialises the PFH list
*/
int init_pfh (void)
{
bloc_mess *bptr = tete_dir;
mess_noeud *mptr;
int offset;
bullist bul;
int i;
FILE *fptr;
init_pac ();
if (pacsat == 0)
return 0;
initq (&actuser);
initq (&freeuser);
for (i = 0; i < MAXUSER; i++)
putq (&freeuser, (struct stqcell *)&user[i]);
initq (&freehole);
for (i = 0; i < MAXHOLE; i++)
putq (&freehole, (struct stqcell *)&hole[i]);
npfhdir = 0;
ouvre_dir ();
offset = 0;
while (bptr)
{
mptr = &(bptr->st_mess[offset]);
if (mptr->noenr)
{
read_dir (mptr->noenr, &bul);
if ((bul.status != 'K') && (bul.status != 'A') && (npfhdir < MAXPFHDIR))
{
pfhdir[npfhdir].t_new = bul.date;
pfhdir[npfhdir].file_id = bul.numero;
pfhdir[npfhdir].pfh_type = PFH_MSG;
npfhdir++;
}
}
if (++offset == T_BLOC_MESS)
{
bptr = bptr->suiv;
offset = 0;
}
}
ferme_dir ();
/* Idem for YAPPLBL.DAT */
fptr = fopen (d_disque ("YAPPLBL.DAT"), "rb");
if (fptr)
{
Rlabel rlabel;
while (fread (&rlabel, sizeof (Rlabel), 1, fptr))
{
if ((*rlabel.nomfic) && (npfhdir < MAXPFHDIR))
{
pfhdir[npfhdir].t_new = rlabel.date_creation;
pfhdir[npfhdir].file_id = rlabel.index;
pfhdir[npfhdir].pfh_type = PFH_FILE;
npfhdir++;
}
}
fclose (fptr);
}
qsort (&pfhdir[0], npfhdir, sizeof (struct stpfhdir), (int (*)(const void *, const void *))compare);
pfhdir[0].t_old = 0;
for (i = 1; i < npfhdir; i++)
{
pfhdir[i].t_old = pfhdir[i - 1].t_new + 1;
}
#ifdef PACDBG
dispdir ();
#endif
if (fbb_ax25_config_load_ports () == 0)
fprintf (stderr, "no AX.25 port data configured\n");
/* Creates RX monitoring socket */
if ((msock = socket (AF_PACKET, SOCK_PACKET, htons (ETH_P_AX25))) == -1)
{
perror ("pacsat socket_monitoring");
}
else
{
/* Non blocking socket */
int ioc = 1;
ioctl (msock, FIONBIO, &ioc);
}
return (npfhdir);
}
void add_pfh (bullist * pbul)
{
if (pacsat == 0)
return;
if ((pbul->status != 'K') && (pbul->status != 'A') && (npfhdir < MAXPFHDIR))
{
if (npfhdir)
pfhdir[npfhdir].t_old = pfhdir[npfhdir - 1].t_new + 1;
else
pfhdir[npfhdir].t_old = 0;
pfhdir[npfhdir].t_new = pbul->date;
pfhdir[npfhdir].file_id = pbul->numero;
send_pfh (npfhdir, MAXBLKSIZE);
npfhdir++;
}
}
static int compare (struct stpfhdir *d1, struct stpfhdir *d2)
{
if (d1->t_new == d2->t_new)
{
return (0);
}
else if ((u_long) d1->t_new > (u_long) d2->t_new)
{
return (1);
}
else
{
return (-1);
}
}
#ifdef PACDBG
/*
* < dispdir > display directory
*/
static void dispdir (void)
{
int i;
for (i = 0; i < npfhdir; i++)
{
printf (" %4d %lu,%lu %lX %d\n", i,
pfhdir[i].t_old, pfhdir[i].t_new, pfhdir[i].file_id,
pfhdir[i].pfh_size);
}
}
#endif
static int add_buf (char *buf, void *data, int nb)
{
memcpy (buf, data, nb);
return (nb);
}
/*
* < send_pfh > send PFH
*/
static uchar send_pfh (int dirent, int block_size)
{
char buf[256];
char out[256];
char *pbuf;
uchar flags;
int psize, size, nb;
long file_id, offset;
file_id = pfhdir[dirent].file_id;
psize = mk_pfh (buf, NULL, file_id);
flags = 0x00;
if ((dirent + 1) == npfhdir)
flags |= 0x40;
offset = 0;
for (;;)
{
size = psize - offset;
if (size <= block_size)
{
flags |= 0x20;
}
else
{
size = block_size;
}
pbuf = buf + offset;
nb = 0;
nb += add_buf (&out[nb], &flags, 1);
nb += add_buf (&out[nb], &file_id, 4);
nb += add_buf (&out[nb], &offset, 4);
nb += add_buf (&out[nb], &pfhdir[dirent].t_old, 4);
nb += add_buf (&out[nb], &pfhdir[dirent].t_new, 4);
nb += add_buf (&out[nb], pbuf, size);
nb = add_crc (out, nb);
snd_pac ("QST-1", out, nb, 0xbd);
if (flags & 0x20)
{
break;
}
offset += size;
}
return (flags);
}
/*
* < req_dir > request directory
*/
static int req_dir (char *callsign)
{
u_char flags;
ushort block_size;
struct stuser *user;
struct sthole *hole;
time_t start, end;
int i;
i = HDRSIZE;
flags = rkss[i];
i += 1;
memcpy (&block_size, &rkss[i], 2);
i += 2;
user = (struct stuser *) getq (&freeuser);
if (user == NULL)
{
return (-1); /* queue full */
}
user->entry_t = time (NULL);
user->flags = F_DIR;
strcpy (user->call, callsign);
user->block_size = block_size;
initq (&user->hole);
putq (&actuser, (struct stqcell *)user);
for (; i < lnrkss; i += (4 + 4))
{
memcpy (&start, &rkss[i], 4);
memcpy (&end, &rkss[i + 4], 4);
hole = (struct sthole *) getq (&freehole);
if (hole == NULL)
break;
hole->start = start;
hole->end = end;
putq (&user->hole, (struct stqcell *)hole);
}
return (0); /* OK */
}
/*
* < pfhstat > PFH stat
*/
static int pfhstat ( char *name, struct stpfh *pfh)
{
FILE *fp;
int c, i, s, length;
char data[256];
ushort id;
s = 0;
if ((fp = fopen (name, "rb")) == NULL)
{
return (-1);
}
c = fgetc (fp);
s++;
id = (c << 8);
c = fgetc (fp);
s++;
id |= c;
if (id != 0xaa55)
{ /* PFH check ? */
fclose (fp);
return (-1);
}
for (;;)
{
c = fgetc (fp);
if (c == EOF)
break;
id = c;
c = fgetc (fp);
id |= (c << 8);
c = fgetc (fp);
length = c;
s += 3;
if (id == 0 && length == 0) /* termination ? */
break;
for (i = 0; i < length; i++)
{
data[i] = fgetc (fp);
s++;
}
switch (id)
{
case 0x04:
memcpy (&pfh->file_size, data, 4);
break;
case 0x08:
pfh->file_type = data[0];
break;
case 0x0b:
memcpy (&pfh->body_offset, data, 2);
break;
default:
break;
}
}
fclose (fp);
pfh->pfh_size = s;
return (0);
}
/*
* < initq > initialize queue
*/
static void initq (struct stqueue *q)
{
q->head = q->tail = NULL;
}
/*
* < putq > put queue
*/
static void putq (struct stqueue *q, struct stqcell *d)
{
if (q == NULL || d == NULL)
{
assert (0);
}
d->next = NULL;
if (q->head == NULL)
{
q->head = q->tail = d;
}
else
{
q->tail->next = d;
q->tail = d;
}
}
/*
* < getq > get queue
*/
static struct stqcell *getq (struct stqueue *q)
{
struct stqcell *r;
if (q == NULL)
{
assert (0);
}
r = q->head;
if (r != NULL)
{
q->head = r->next;
}
if (q->head == NULL)
{
q->tail = NULL;
}
return (r);
}
/*
* < delq > delete queue
*/
static void delq (struct stqueue *q, struct stqcell *d)
{
struct stqcell *d2;
struct stqueue temp;
initq (&temp);
while ((d2 = getq (q)) != NULL)
{
if (d2 != d)
{
putq (&temp, d2);
}
}
*q = temp;
}
/*
* < timer > timer
*/
static void timer (void)
{
static long t1;
long clk, t;
clk = btime ();
t = clk - t1;
t1 = clk;
if ((u_long) tim_0 > (u_long) t)
{
tim_0 -= t;
}
else
tim_0 = 0;
if ((u_long) tim_1 > (u_long) t)
{
tim_1 -= t;
}
else
tim_1 = 0;
if ((u_long) tim_2 > (u_long) t)
{
tim_2 -= t;
}
else
tim_2 = 0;
t *= 100;
if ((u_long) tim_3 > (u_long) t)
{
tim_3 -= t;
}
else
tim_3 = 0;
}
/*
* < pblist > PB list
*/
static void pblist (int ctl)
{
VOID add_kss (char *, int);
char buf[256];
int n;
struct stuser *user;
if (f_beacon)
{
f_beacon = OFF;
tim_0 = 0;
}
if (ctl == 1)
tim_0 = 0;
else
{
if (tim_0 != 0 || actuser.head != NULL)
return;
}
if (tim_0 != 0)
return;
tim_0 = to_empty;
strcpy (buf, "PB:");
user = (struct stuser *) actuser.head;
n = 0;
if (user == NULL)
{
strcat (buf, " Empty.");
}
else
{
while (user != NULL)
{
strcat (buf, " ");
strcat (buf, user->call);
if (user->flags & F_DIR)
strcat (buf, "\\D");
user = user->next;
n++;
}
}
strcat (buf, "\r");
snd_pac ("PBLIST", buf, strlen (buf), 0xf0);
}
/*
* < qst >
*/
static void qst (void)
{
struct stuser *user;
if (actuser.head == NULL)
return;
if (tim_3)
{
return;
}
pblist (1);
user = (struct stuser *) getq (&actuser);
/* check time over ? */
if ((time (NULL) - user->entry_t) > to_user)
{
del_user (user);
return;
}
if (user->flags & F_DIR)
{
qst_dir (user);
}
else
{
qst_bul (user);
}
if (user->hole.head == NULL)
{
putq (&freeuser, (struct stqcell *)user);
/* Termine... Supprime le fichier si pas utilise */
rm_pfh_file (user->file_id);
}
else
{
putq (&actuser, (struct stqcell *)user);
}
if (actuser.head == NULL)
{
pblist (1);
}
}
/*
* < qst_dir > directory
*/
static void qst_dir (struct stuser *user)
{
struct sthole *hole;
u_char flags;
int i, j, dirent;
int nb_blk = (baud / 600);
if (nb_blk > 10)
nb_blk = 10;
for (i = 0; i < nb_blk; i++)
{
hole = (struct sthole *) user->hole.head;
if (hole == NULL)
break;
dirent = npfhdir - 1;
for (j = 0; j < npfhdir; j++)
{
if ((u_long) hole->start >= (u_long) pfhdir[j].t_old &&
(u_long) hole->start <= (u_long) pfhdir[j].t_new)
{
dirent = j;
break;
}
}
flags = send_pfh (dirent, user->block_size);
hole->start = pfhdir[dirent].t_new + 1;
if ((u_long) hole->start > (u_long) hole->end || (flags & 0x40))
{ /* hole delete ? */
hole = (struct sthole *) getq (&user->hole);
putq (&freehole, (struct stqcell *)hole);
}
}
}
/*
* < qst_bul >
*/
static void qst_bul (struct stuser *user)
{
struct sthole *hole;
char name[128];
char buf[256];
char out[256];
FILE *fp;
char flags, file_type;
long file_id, offset;
int i;
int nb;
int size;
int nb_blk = (baud / 600);
if (nb_blk > 10)
nb_blk = 10;
file_id = user->file_id;
file_type = user->file_type;
strcpy (name, dlname (file_id));
if ((fp = fopen (name, "rb")) == NULL)
{
printf ("QST-1 file[%s] open error\n", name);
exit (1);
}
flags = 0x02;
for (i = 0; i < nb_blk; i++)
{
hole = (struct sthole *) user->hole.head;
if (hole == NULL)
{
break;
}
offset = hole->offset;
if (user->block_size > hole->length)
{
size = hole->length;
}
else
{
size = user->block_size;
}
hole->offset += (long) size;
hole->length -= size;
if (hole->length == 0)
{
hole = (struct sthole *) getq (&user->hole);
putq (&freehole, (struct stqcell *)hole);
}
fseek (fp, offset, SEEK_SET);
fread (buf, size, 1, fp);
nb = 0;
nb += add_buf (&out[nb], &flags, 1);
nb += add_buf (&out[nb], &file_id, 4);
nb += add_buf (&out[nb], &file_type, 1);
nb += add_buf (&out[nb], &offset, 3);
nb += add_buf (&out[nb], buf, size);
nb = add_crc (out, nb);
snd_pac ("QST-1", out, nb, 0xbb);
}
fclose (fp);
}
/*
* < rcvreq > receive request
*/
static void rcvreq (void)
{
char callsign[12];
int r;
u_char pid;
if (!f_rkss)
return;
f_rkss = OFF;
if (lnrkss <= HDRSIZE)
return;
pid = rkss[HDRSIZE - 1] & 0xff;
/* Verify if the request is for me */
if (strcmp (pac_call, ax25_ntoaii (rkss + 1)) != 0)
{
return;
}
strcpy (callsign, ax25_ntoaii (rkss + 1 + ADRSIZE));
del_user (sch_user (callsign));
switch (pid)
{
case 0xbb: /* pid = bb */
r = req_bul (callsign);
break;
case 0xbd: /* pid = bd */
r = req_dir (callsign);
break;
default:
return;
}
res_msg (callsign, r);
}
/*
* < res_msg > response messages
*/
static void res_msg (char *callsign, int errorcode)
{
char buf[64];
if (errorcode == 0)
{
sprintf (buf, "OK %s\r", callsign);
}
else
{
sprintf (buf, "NO %d %s\r", errorcode, callsign);
}
snd_pac (callsign, buf, strlen (buf), 0xf0);
}
static int findfile (int id)
{
FILE *fptr;
Rlabel rlabel;
int ret = -1;
int record = 0;
/* Seach file in the existing labels */
if ((fptr = fopen (d_disque ("YAPPLBL.DAT"), "rb")) == NULL)
return (ret);
while (fread (&rlabel, sizeof (Rlabel), 1, fptr))
{
if ((*rlabel.nomfic) && (rlabel.index == id))
{
ret = record;
break;
}
++record;
}
fclose (fptr);
return (ret);
}
/*
* < req_bul > request
*/
static int req_bul (char *callsign)
{
uchar flags;
long file_id, offset;
ushort block_size, length;
int i;
int file_type;
struct stuser *user;
i = HDRSIZE;
flags = rkss[i];
i += 1;
memcpy (&file_id, &rkss[i], 4);
i += 4;
memcpy (&block_size, &rkss[i], 2);
i += 2;
if (findmess (file_id) == NULL)
{
/* Not a msg... Is it a file ? */
if (findfile (file_id) != -1)
{
file_type = PFH_FILE;
}
else
{
/* None exist */
return (-2);
}
}
else
{
file_type = PFH_MSG;
}
user = (struct stuser *) getq (&freeuser);
if (user == NULL)
{
return (-1); /* queue full */
}
/* Create the DL file */
if (mk_pfh_file (file_id, file_type) == 0)
return (-2);
if (access (dlname (file_id), 00) != 0)
{ /* DL file exist ? */
return (-2); /* file does not exist */
}
switch (flags & 0x03)
{
case 0x00: /* start */
set_user (user, callsign, file_id, block_size);
offset = 0;
length = block_size * 10;
for (i = 0; i < 10; i++)
{
add_hole (user, offset, length);
offset += length;
}
break;
case 0x01: /* stop */
break;
case 0x02: /* hole list */
set_user (user, callsign, file_id, block_size);
for (; i < lnrkss; i += (3 + 2))
{
offset = 0;
memcpy (&offset, &rkss[i], 3);
memcpy (&length, &rkss[i + 3], 2);
add_hole (user, offset, length);
}
break;
default:
return (-4); /* debug */
break;
}
return (0); /* OK */
}
/*
* < set_user > set user list
*/
static void set_user (struct stuser *user, char *callsign, long file_id, ushort block_size)
{
struct stat sbuf;
struct stpfh pfh;
char pathname[128];
strcpy (pathname, dlname (file_id));
stat (pathname, &sbuf);
pfhstat (pathname, &pfh);
user->entry_t = time (NULL);
user->flags = 0x0000;
strcpy (user->call, callsign);
user->file_id = file_id;
user->file_type = pfh.file_type;
user->file_size = sbuf.st_size;
if (block_size > MAXBLKSIZE)
{ /* block size adjust */
user->block_size = MAXBLKSIZE;
}
else
{
user->block_size = block_size;
}
initq (&user->hole);
putq (&actuser, (struct stqcell *)user);
}
/*
* < add_hole >
*/
static void add_hole (struct stuser *user, long offset, ushort length)
{
struct sthole *hole;
if (offset >= user->file_size)
return;
if (offset + length > user->file_size) /* adjust */
length = user->file_size - offset;
hole = (struct sthole *) getq (&freehole);
if (hole == NULL)
{
assert (0);
}
hole->offset = offset;
hole->length = length;
putq (&user->hole, (struct stqcell *)hole);
}
/*
* < sch_user > search user
*/
static struct stuser *sch_user (char *callsign)
{
struct stuser *user;
user = (struct stuser *) actuser.head;
while (user)
{
if (strcmp (user->call, callsign) == 0)
{
break;
}
user = (struct stuser *) user->next;
}
return (user);
}
/*
* < del_user > delete user
*/
static void del_user (struct stuser *user)
{
struct sthole *hole;
if (user == NULL)
return;
while ((hole = (struct sthole *) getq (&user->hole)) != NULL)
{
putq (&freehole, (struct stqcell *)hole);
}
delq (&actuser, (struct stqcell *)user);
putq (&freeuser, (struct stqcell *)user);
}
static int add_struct (char *buf, int id, void *data, int lg_data)
{
*buf++ = id & 0xff;
*buf++ = id >> 8;
*buf++ = lg_data;
memcpy (buf, data, lg_data);
lg_data += 3;
return (lg_data);
}
static int pfh_msg (FILE * fpth, long numero)
{
/* int verbose = 1; */
FILE *fptm;
int fd_msg;
int fd_pfh;
int i, nb, wr, tot, lgbuf;
uchar buf[4096];
if (fpth)
{
fflush (fpth);
fd_pfh = fileno (fpth);
}
else
fd_pfh = 0;
if ((fptm = ouvre_mess (O_TEXT, numero, '\0')) != NULL)
{
fd_msg = fileno (fptm);
}
else
return 0;
crc = 0;
tot = 0;
wr = 0;
lgbuf = sizeof (buf);
for (;;)
{
nb = read (fd_msg, buf, lgbuf);
if (nb <= 0)
break;
if (fd_pfh)
wr = write (fd_pfh, buf, nb);
for (i = 0; i < nb; i++)
{
crc += buf[i];
}
tot += nb;
}
fclose (fptm);
return tot;
}
struct pfh1
{
unsigned short id __a1__;
uchar len __a1__;
uchar val __a1__;
};
struct pfh2
{
unsigned short id __a1__;
uchar len __a1__;
unsigned short val __a1__;
};
struct pfh3
{
unsigned short id __a1__;
uchar len __a1__;
//uchar val[3] __a1__;
uchar val[4] __a1__; // only used for file_ext in sprintf but there wasn't room for the trailing null
};
struct pfh4
{
unsigned short id __a1__;
uchar len __a1__;
unsigned long val __a1__;
};
struct pfh8
{
unsigned short id __a1__;
uchar len __a1__;
//uchar val[8] __a1__;
uchar val[9] __a1__; // only used for file_name in sprintf but there wasn't room for the trailing null
};
struct pfh
{
unsigned short magic_number __a1__;
struct pfh4 file_number __a1__;
struct pfh8 file_name __a1__;
struct pfh3 file_ext __a1__;
struct pfh4 file_size __a1__;
struct pfh4 create_time __a1__;
struct pfh4 last_modif_time __a1__;
struct pfh1 seu_flag __a1__;
struct pfh1 file_type __a1__;
struct pfh2 body_checksum __a1__;
struct pfh2 header_checksum __a1__;
struct pfh2 body_offset __a1__;
};
static int mk_pfh (char *buf, bullist * pbul, long numero)
{
bullist bul;
mess_noeud *lptr;
int lg;
int i;
int nb;
int zero = 0;
struct pfh *pfh = (struct pfh *) buf;
uchar *ptr;
char lbuf[80];
if (pbul == NULL)
{
lptr = findmess (numero);
if (lptr == NULL)
return (0);
ouvre_dir ();
read_dir (lptr->noenr, &bul);
ferme_dir ();
pbul = &bul;
}
lg = pfh_msg (NULL, pbul->numero);
pfh->magic_number = 0x55aa;
pfh->file_number.id = 1;
pfh->file_number.len = 4;
pfh->file_number.val = pbul->numero;
pfh->file_name.id = 2;
pfh->file_name.len = 8;
sprintf (pfh->file_name.val, " ");
pfh->file_ext.id = 3;
pfh->file_ext.len = 3;
sprintf (pfh->file_ext.val, " ");
pfh->create_time.id = 5;
pfh->create_time.len = 4;
pfh->create_time.val = pbul->date;
pfh->last_modif_time.id = 6;
pfh->last_modif_time.len = 4;
pfh->last_modif_time.val = 0;
pfh->seu_flag.id = 7;
pfh->seu_flag.len = 1;
pfh->seu_flag.val = 0;
pfh->file_type.id = 8;
pfh->file_type.len = 1;
pfh->file_type.val = 0;
pfh->body_checksum.id = 9;
pfh->body_checksum.len = 2;
pfh->body_checksum.val = crc;
pfh->header_checksum.id = 0xa;
pfh->header_checksum.len = 2;
pfh->header_checksum.val = 0;
nb = sizeof (struct pfh);
nb += add_struct (&buf[nb], 0x10, pbul->exped, strlen (pbul->exped));
sprintf (lbuf, "%-6s", pbul->exped);
nb += add_struct (&buf[nb], 0x11, lbuf, 6);
nb += add_struct (&buf[nb], 0x12, &pbul->date, 4);
nb += add_struct (&buf[nb], 0x13, &pbul->nblu, 1);
if (*pbul->bbsv)
sprintf (lbuf, "%s@%s", pbul->desti, pbul->bbsv);
else
sprintf (lbuf, "%s", pbul->desti);
nb += add_struct (&buf[nb], 0x14, lbuf, strlen (lbuf));
nb += add_struct (&buf[nb], 0x15, " ", 6);
nb += add_struct (&buf[nb], 0x16, &zero, 4);
nb += add_struct (&buf[nb], 0x17, &zero, 4);
nb += add_struct (&buf[nb], 0x18, &zero, 1);
nb += add_struct (&buf[nb], 0x19, &zero, 1);
nb += add_struct (&buf[nb], 0x20, &pbul->type, 1);
nb += add_struct (&buf[nb], 0x21, pbul->bid, strlen (pbul->bid));
nb += add_struct (&buf[nb], 0x22, pbul->titre, strlen (pbul->titre));
buf[nb++] = '\0';
buf[nb++] = '\0';
buf[nb++] = '\0';
pfh->file_size.id = 4;
pfh->file_size.len = 4;
pfh->file_size.val = lg + nb;
pfh->body_offset.id = 0xb;
pfh->body_offset.len = 2;
pfh->body_offset.val = (unsigned short) nb;
/* Computing header checksum */
ptr = (char *) pfh;
for (chck = 0, i = 0; i < nb; ptr++, i++)
{
chck += 0xff & (unsigned short) *ptr;
}
pfh->header_checksum.val = chck;
return (nb);
}
static int mk_pfh_file (long numero, int type)
{
int nb = 0;
FILE *fptr;
char header[256];
if (type == PFH_MSG)
{
nb = mk_pfh (header, NULL, numero);
if (nb == 0)
return (0);
if (access (dlname (numero), 00) == 0)
return (1);
fptr = fopen (dlname (numero), "wb");
if (fptr == NULL)
return (0);
fwrite (header, nb, 1, fptr);
nb = pfh_msg (fptr, numero);
fclose (fptr);
}
if (type == PFH_FILE)
{
nb = 0;
}
return nb;
}
/*
* < dlname > pathname DL file
*/
static char *dlname (long numero)
{
static char pathname[128];
sprintf (pathname, "%s%lx.dl", MBINDIR, numero);
return (pathname);
}
static void rm_pfh_file (long numero)
{
struct stuser *user;
user = (struct stuser *) actuser.head;
while (user)
{
if (((user->flags & F_DIR) == 0) && (user->file_id == numero))
{
/* used by another user */
return;
}
user = user->next;
}
/* unlink the DL file */
unlink (dlname (numero));
}
static int add_crc (char *buf, int nb)
{
int j;
short crc;
for (j = 0, crc = 0; j < nb; j++)
{
crc = calc_crc (buf[j], crc);
}
buf[j++] = (crc >> 8) & 0xff;
buf[j++] = crc & 0xff;
return (j);
}
static void snd_pac (char *desti, char *buf, int len, int pid)
{
static int s_f0 = -1;
static int s_bb = -1;
static int s_bd = -1;
int slen;
int dlen;
fs_ax25 dst;
fs_ax25 src;
char *call = NULL;
int s = -1;
long temps;
switch (pid)
{
case 0xbb:
s = s_bb;
break;
case 0xbd:
s = s_bd;
break;
case 0xf0:
s = s_f0;
break;
}
if (s == -1)
{
slen = ax25_aton (pac_call, &src);
call = ax25_config_get_addr (pac_port);
if (call == NULL)
{
printf ("Cannot find a callsign for port %s\n",
pac_port);
return;
}
ax25_aton_entry (call, src.fsa_digipeater[0].ax25_call);
src.fsa_ax25.sax25_ndigis = 1;
if ((s = socket (AF_AX25, SOCK_DGRAM, pid)) == -1)
{
perror ("beacon:socket");
return;
}
if (bind (s, (struct sockaddr *) &src, slen) == -1)
{
perror ("beacon:bind");
return;
}
switch (pid)
{
case 0xbb:
s_bb = s;
break;
case 0xbd:
s_bd = s;
break;
case 0xf0:
s_f0 = s;
break;
}
}
if ((dlen = ax25_aton (desti, &dst)) == -1)
{
fprintf (stderr, "beacon: unable to convert '%s'\n", call);
return;
}
if (sendto (s, buf, len, 0, (struct sockaddr *) &dst, dlen) == -1)
{
perror ("beacon: sendto");
return;
}
temps = (TIME ((len + HDRSIZE))) * 1000 / baud;
tim_3 += temps;
}
static int rcvkss (void)
{
struct sockaddr sa;
unsigned asize = sizeof (sa);
int lg;
char *ptr;
lnrkss = 0;
if (msock == -1)
return (0);
lg = recvfrom (msock, rkss, FRMSIZE, 0, &sa, &asize);
if (lg <= 0)
return (0);
if ((ptr = ax25_config_get_name (sa.sa_data)) != NULL)
{
/* printf("Received UI on port %s, lg=%d\n", ptr, lg); */
}
lnrkss = lg;
f_rkss = ON;
return (lg);
}
static char *ax25_ntoaii (char *call)
{
char *scan;
char *ptr = _ax25_ntoa ((ax25_address *)call);
scan = strrchr (ptr, '-');
if ((scan) && (*(scan + 1) == '0'))
*scan = '\0';
return (ptr);
}
fbb-7.0.11/src/dos_dir.c 0000664 0001750 0001750 00000037220 13614261151 011636 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
#include
#ifdef __linux__
#include
#endif
static int dir_time (char *);
static long parcours (char, char *);
int is_dir (char *chaine)
{
#ifdef __linux__
struct stat st;
int ret;
if ((strlen (chaine) > 2) && (chaine[1] == ':'))
chaine += 2;
ret = stat (back2slash (chaine), &st);
if (ret == -1)
return (0);
return (S_ISDIR (st.st_mode));
#endif
#if defined(__FBBDOS__) || defined (__WINDOWS__)
int hand;
struct dfree dtable;
/* Teste la racine car NOVELL ne reconnait pas C:\ comme repertoire !!! */
if ((isalpha (chaine[0])) && (chaine[1] == ':') && (chaine[2] == '\\') && (!chaine[3]))
{
getdfree (toupper (chaine[0]) - '@', &dtable);
if (dtable.df_sclus == 0xffff)
{
/* Disque non valide ? */
return (0);
}
else
return (1);
}
/* Fin du rajout NOVELL */
if (access (chaine, 0) == 0)
{
hand = open (chaine, O_RDONLY); /* Repertoire ou fichier ? */
if (hand == -1)
{
return (1);
}
else
{
close (hand);
return (0);
}
}
return (0);
#endif
}
void prompt_dos (void)
{
char *scan;
char *ptr = local_path (pvoie->dos_path);
if ((scan = strchr (ptr, ':')) != NULL)
ptr = scan + 1;
var_cpy (0, ptr);
texte (T_DOS + 0);
maj_niv (9, 0, 0);
}
static int dir_time (char *indic)
{
int lg = strlen (indic);
int pos;
int c[3];
for (pos = 0; pos < 3; c[pos++] = '\0')
;
pos = 0;
while (lg--)
{
if (isalpha (indic[lg]))
c[pos++] = (int) (indic[lg] - 'A');
if (pos == 3)
break;
}
return (c[0] | (c[1] << 5) | (c[2] << 10));
}
void wr_dir (char *fichier, char *indic)
{
#if defined(__FBBDOS__) || defined(__WINDOWS__)
int fd;
int dt = dir_time (indic);
long temps = time (NULL);
struct tm *sdate;
struct ftime dirtime;
sdate = localtime (&temps);
dirtime.ft_year = sdate->tm_year %100;
dirtime.ft_day = sdate->tm_mday;
dirtime.ft_month = sdate->tm_mon + 1;
dirtime.ft_hour = dt >> 11;
dirtime.ft_min = (dt >> 5) & 0x3f;
dirtime.ft_tsec = dt & 0x1f;
if ((fd = open (fichier, O_RDONLY)) != -1)
{
setftime (fd, &dirtime);
close (fd);
}
#endif
#ifdef __linux__
struct utimbuf buf;
long temps = time (NULL);
struct tm *sdate;
/* int dt = dir_time (indic);
int heure = dt >> 11;
int minute = (dt >> 5) & 0x3f;
int seconde = (dt & 0x1f) << 1;
*/
sdate = localtime (&temps);
/* sdate->tm_hour = heure;
sdate->tm_min = minute;
sdate->tm_sec = seconde;
*/
buf.actime = buf.modtime = mktime (sdate);
if (utime (back2slash (fichier), &buf) != 0)
perror ("utime");
#endif
}
int aut_dir (char *fichier, char *indic)
{
if (droits (SUPFIC))
{
return (1);
}
else
{
#if defined(__FBBDOS__) || defined(__WINDOWS__)
union
{
struct ftime dirtime;
struct
{
int time;
int date;
}
dtime;
}
utime;
int fd;
if ((fd = open (fichier, O_RDONLY)) == -1)
return (1);
getftime (fd, &(utime.dirtime));
close (fd);
return (utime.dtime.time == dir_time (indic));
#endif
#ifdef __linux__
int fd;
struct stat buf;
time_t temps;
struct tm *sdate;
int dt;
if ((fd = open (fichier, O_RDONLY)) == -1)
return (1);
fstat (fd, &buf);
temps = buf.st_mtime;
close (fd);
sdate = localtime (&temps);
dt = (sdate->tm_hour << 11) + (sdate->tm_min << 5) + (sdate->tm_sec >> 1);
return (dt == dir_time (indic));
#endif
}
}
static int protected_dir(char *file)
{
int protected = 0;
char nomfich[256];
FILE *fptr;
char *ptr, *scan;
char ligne[81];
#ifdef __FBBDOS__
if ((fptr = fopen (c_disque ("prot_d.sys"), "r")) == NULL)
#endif
#ifdef __WINDOWS__
if ((fptr = fopen (c_disque ("prot_w.sys"), "r")) == NULL)
#endif
#ifdef __linux__
if ((fptr = fopen (c_disque ("prot_l.sys"), "r")) == NULL)
#endif
{
fptr = fopen (c_disque ("protect.sys"), "r");
}
if (fptr)
{
while (fgets (ligne, 80, fptr))
{
ptr = scan = ligne;
while ((*scan) && (!ISGRAPH (*scan)))
++scan;
while (ISGRAPH (*scan))
*ptr++ = *scan++;
*ptr = '\0';
if (*ligne == '#' || *ligne == '\0')
continue;
strcpy (nomfich, tot_path (file, pvoie->dos_path));
#ifdef __linux__
ptr = strrchr (nomfich, '/');
if (ptr == nomfich)
strcpy (nomfich, "/");
#else
ptr = strrchr (nomfich, '\\');
if (ptr == nomfich)
strcpy (nomfich, "\\");
else
*ptr = '\0';
#endif
#ifdef __linux__
ptr = ligne;
scan = nomfich;
if (ptr[1] != ':' && nomfich[1] == ':')
scan += 2;
#else
ptr = slash2back(ligne);
scan = nomfich;
#endif
if (strncmpi (ptr, scan, strlen(ptr)) == 0)
{
protected = 1;
break;
}
}
ferme (fptr, 77);
}
return protected;
}
int aut_ecr (char *fichier, int check_dir)
{
int supp = TRUE;
char *ptr, *scan;
char nomfich[256];
if (droits (ACCESDOS) && droits (SUPFIC) && (*fichier == '+'))
{
if (*fichier == '+')
{
/* Deletes the '+' character */
ptr = scan = fichier;
++scan;
while ((*ptr++ = *scan++) != '\0')
;
}
}
else
{
if (check_dir)
supp = !protected_dir(fichier);
if ((supp) && (!droits (ACCESDOS)))
{
strcpy (nomfich, tot_path (fichier, pvoie->dos_path));
supp = aut_dir (nomfich, pvoie->sta.indicatif.call);
}
}
if (!supp)
{
strcpy (pvoie->appendf, fichier);
texte (T_ERR + 23);
}
return (supp);
}
/*
static int exist(char*file)
{
return (access(local_path(tot_path(file, pvoie->dos_path)), 0) == 0) ;
}
*/
void remove_dir (void)
{
char *ptr;
get_nextparam();
if ((ptr = get_nextparam()) == NULL)
{
texte (T_ERR + 25);
}
else
{
if (tst_point (ptr))
{
if (aut_ecr (ch_slash (ptr), 1))
{
var_cpy (0, ptr);
#ifdef __linux__
if (fbb_rmdir (tot_path (ptr, pvoie->dos_path)) == 0)
#else
if (rmdir (tot_path (ptr, pvoie->dos_path)) == 0)
#endif
texte (T_DOS + 1);
else
texte (T_ERR + 24);
}
}
}
prompt_dos ();
}
void make_dir (void)
{
char *ptr, *path;
get_nextparam();
if ((ptr = get_nextparam()) == NULL)
{
texte (T_ERR + 25);
}
else
{
#ifdef __linux__
path = tot_path (ptr, pvoie->dos_path);
if (fbb_mkdir (path, 0777) != 0)
{
var_cpy (0, ptr);
texte (T_ERR + 26);
}
else
{
wr_dir (path, pvoie->sta.indicatif.call);
}
#endif
#if defined(__FBBDOS__) || defined(__WINDOWS__)
ch_slash (ptr);
if (mkdir (tot_path (ptr, pvoie->dos_path)) != 0)
{
var_cpy (0, ptr);
texte (T_ERR + 26);
}
#endif
}
prompt_dos ();
}
static void teste_file_name (char *ptr)
{
/*
int ok;
int lg = 0;
int max = 8;
char *ptro = ptr;
while (*ptr)
{
ok = 1;
if (*ptr == '.')
{
lg = 0;
max = 3;
}
else if (*ptr == '\\')
{
lg = 0;
max = 8;
}
else if (++lg > max)
{
ok = 0;
}
if (ok)
*ptro++ = *ptr;
++ptr;
}
*ptro = '\0';
*/
}
void change_dir (void)
{
int nb;
char local_dir[256], *ptr, *scan, *cur_dir;
strcpy (local_dir, pvoie->dos_path);
get_nextparam();
if ((ptr = get_nextparam()) == NULL)
{
nb = strlen (local_dir);
if (nb > 1)
{
--nb;
local_dir[nb] = '\0';
}
outln (local_dir, nb);
}
else
{
#ifdef __linux__
teste_file_name (ptr);
if (*ptr == '/')
#else
ch_slash (ptr);
teste_file_name (ptr);
if (*ptr == '\\')
#endif
{
if (tst_point (ptr))
{
strcpy (local_dir, ptr);
if (strlen (local_dir) > 1)
#ifdef __linux__
strcat (local_dir, "/");
#else
strcat (local_dir, "\\");
#endif
}
}
else
{
#ifdef __linux__
if ((scan = strtok (ptr, "\n")) != NULL)
#else
if ((scan = strtok (ptr, "\\\r")) != NULL)
#endif
{
do
{
if (strcmp (scan, ".") == 0)
continue;
if (strncmp (scan, "..", 2) == 0)
{
#ifdef __linux__
cur_dir = strrchr (local_dir, '\\');
#else
cur_dir = strrchr (local_dir, "\\");
#endif
if (cur_dir != local_dir)
{
do
{
*cur_dir-- = '\0';
}
#ifdef __linux__
while (*cur_dir != '\\');
#else
while (*cur_dir != "\\");
#endif
}
}
else if (*scan != '~')
{
strcat (local_dir, scan);
#ifdef __linux__
strcat (local_dir, "/");
#else
strcat (local_dir, "\\");
#endif
}
}
#ifdef __linux__
while ((scan = strtok (NULL, "\n")) != NULL);
#else
while ((scan = strtok (NULL, "\\\r")) != NULL);
#endif
}
}
if (strlen (local_dir) > 255)
texte (T_ERR + 28);
else
{
char ldir[256];
char *ptr;
strcpy(ldir, tot_path ("\0", local_dir));
ptr = long_filename(NULL, ldir);
if (is_dir (local_path (ptr)) > 0)
strcpy (pvoie->dos_path, ptr + strlen(ptr) - strlen(local_dir));
else
texte (T_ERR + 29);
}
}
prompt_dos ();
}
char *dir_date (int date)
{
int jour, mois, annee;
static char ch_date[11];
jour = date & 0x1f;
mois = (date >> 5) & 0x0f;
annee = ((date >> 9) & 0x3f);
sprintf (ch_date, "%02d-%02d-%02d", jour, mois, annee % 100);
return (ch_date);
}
int dir_suite (char *masque)
{
int n;
char chaine[257];
char temp[257];
if (masque)
{
strcpy (temp, tot_path (ch_slash (masque), pvoie->dos_path));
n = strlen (temp);
if ((n > 3) && (temp[n - 1] == '\\'))
temp[n - 1] = '\0';
if (is_dir (temp))
{
if ((strlen (masque) == 3) && (masque[2] == '\\'))
masque[2] = '\0';
#ifdef __linux__
sprintf (chaine, "%s/*", masque);
#else
sprintf (chaine, "%s/*.*", masque);
#endif
masque = chaine;
}
if (findfirst (tot_path (ch_slash (masque), pvoie->dos_path), &(pvoie->dirblk), FA_DIREC))
{
texte (T_DOS + 2);
return (FALSE);
}
if (*pvoie->dirblk.ff_name == '.')
{
findnext (&(pvoie->dirblk));
if (findnext (&(pvoie->dirblk)))
{
texte (T_DOS + 2);
return (FALSE);
}
}
var_cpy (3, pvoie->dirblk.ff_name);
var_cpy (2, dir_date (pvoie->dirblk.ff_fdate));
*varx[0] = '\0';
*varx[4] = *varx[5] = *varx[6] = *varx[7] = '\0';
if ((pvoie->dirblk.ff_attrib & FA_DIREC) != 0)
{
var_cpy (1, " ");
}
else
{
long size = pvoie->dirblk.ff_fsize;
if (size > (99999 * 1024))
sprintf (varx[1], "%5ld M", size / (1024 * 1024));
else if (size > 999999)
sprintf (varx[1], "%5ld K", size / 1024);
else
sprintf (varx[1], "%7ld", size);
}
/* if (findnext (&(pvoie->dirblk)))
{
*varx[4] = *varx[5] = *varx[6] = *varx[7] = '\0';
texte (T_DOS + 3);
return (FALSE);
}
sprintf (varx[4], "%-13s", pvoie->dirblk.ff_name);
var_cpy (6, dir_date (pvoie->dirblk.ff_fdate));
*varx[7] = '\0';
if ((pvoie->dirblk.ff_attrib & FA_DIREC) != 0)
{
var_cpy (5, " ");
}
else
{
sprintf (varx[5], "%7ld", pvoie->dirblk.ff_fsize);
}*/
texte (T_DOS + 3);
}
while (1)
{
if (findnext (&(pvoie->dirblk)))
return (FALSE);
/* sprintf (varx[0], "%-13s", pvoie->dirblk.ff_name); */
var_cpy (3, pvoie->dirblk.ff_name);
var_cpy (2, dir_date (pvoie->dirblk.ff_fdate));
*varx[0] = '\0';
*varx[4] = *varx[5] = *varx[6] = *varx[7] = '\0';
if ((pvoie->dirblk.ff_attrib & FA_DIREC) != 0)
{
var_cpy (1, " ");
}
else
{
long size = pvoie->dirblk.ff_fsize;
if (size > (99999 * 1024))
sprintf (varx[1], "%5ld M", size / (1024 * 1024));
else if (size > 999999)
sprintf (varx[1], "%5ld K", size / 1024);
else
sprintf (varx[1], "%7ld", size);
}
/* if (findnext (&(pvoie->dirblk)))
{
*varx[4] = *varx[5] = *varx[6] = *varx[7] = '\0';
texte (T_DOS + 3);
return (FALSE);
}
sprintf (varx[4], "%-13s", pvoie->dirblk.ff_name);
var_cpy (6, dir_date (pvoie->dirblk.ff_fdate));
*varx[7] = '\0';
if ((pvoie->dirblk.ff_attrib & FA_DIREC) != 0)
{
var_cpy (5, " ");
}
else
{
sprintf (varx[5], "%7ld", pvoie->dirblk.ff_fsize);
}*/
texte (T_DOS + 3);
}
/* return(TRUE) ; */
}
void retour_dir (char vdisk)
{
int disk;
if (vdisk == 8)
disk = (pvoie->finf.priv[1] == ':') ? pvoie->finf.priv[0] - '@' : getdisk () + 1;
else if ((voiecur == CONSOLE) || (pvoie->niv1 == N_YAPP))
disk = vdisk + 1;
else
#ifdef __linux__
disk = vdisk + 1;
#else
disk = PATH[vdisk][0] - '@';
#endif
ultoa (free_disk (disk) * 1024UL, varx[0], 10);
texte (T_DOS + 11);
retour_dos ();
}
void dir (void)
{
char vdisk;
char *ptr;
#ifdef __linux__
char temp[] = "X:*";
#else
char temp[] = "X:*.*";
#endif
get_nextparam();
pvoie->noenr_menu = 0L;
ptr = get_nextparam();
if (ptr == NULL)
{
temp[0] = (pvoie->vdisk == 8) ? 'P' : pvoie->vdisk + 'A';
ptr = temp;
}
vdisk = pvoie->vdisk;
if ((*(ptr + 1) == ':') && (*(ptr + 2) == '\0'))
{
temp[0] = *ptr;
vdisk = *ptr - 'A';
if (vdisk == 15)
vdisk = 8;
ptr = temp;
}
if (!tst_point (ptr))
retour_dos ();
else if (dir_suite (ptr))
{
texte (T_TRT + 11);
maj_niv (9, 1, 1);
}
else
retour_dir (vdisk);
}
void list (void)
{
char vdisk;
char *ptr;
#ifdef __linux__
char temp[] = "X:*";
#else
char temp[] = "X:*.*";
#endif
get_nextparam();
ptr = get_nextparam();
if (ptr == NULL)
{
temp[0] = (pvoie->vdisk == 8) ? 'P' : pvoie->vdisk + 'A';
ptr = temp;
}
vdisk = pvoie->vdisk;
if ((*(ptr + 1) == ':') && (*(ptr + 2) == '\0'))
{
temp[0] = *ptr;
vdisk = *ptr - 'A';
if (vdisk == 13)
vdisk = 8;
ptr = temp;
}
#if 0
if ((ptr = strtok (NULL, " \r")) == NULL)
{
ptr = temp;
}
liste_label ();
if (!tst_point (ptr))
retour_dos ();
if (dir_yapp (ptr))
{
texte (T_TRT + 11);
ch_niv3 (1);
}
else
{
pvoie->noenr_menu = 0L;
libere_label (voiecur);
retour_dir ();
}
#endif
if (tst_point (ptr))
{
dir_yapp (ptr);
retour_dir (vdisk);
}
else
retour_dos ();
}
static long parcours (char vdisk, char *path)
{
struct ffblk ffblk;
long total = 0L;
long local = 0L;
char rech[80];
char temp[128];
int done = 1;
int pos;
strcpy (rech, path);
#ifdef __linux__
strcat (rech, "*");
#else
strcat (rech, "*.*");
#endif
if (voiecur == CONSOLE)
pos = 0;
else
{
char *ptr = PATH[(int)vdisk];
pos = strlen (ptr) - 1;
if (ptr[1] == ':')
pos -= 2;
}
done = findfirst (rech, &ffblk, FA_DIREC);
while (!done)
{
if (*ffblk.ff_name != '.')
{
#ifdef __linux__
if ((ffblk.ff_attrib & FA_DIREC) && ((ffblk.ff_attrib & FA_LINK) == 0))
#else
if (ffblk.ff_attrib & FA_DIREC)
#endif
{
strcpy (temp, path);
strcat (temp, ffblk.ff_name);
strcat (temp, "\\");
if (strncmp (temp + 1, ":\\PROC\\", 7) != 0)
{
total += parcours (vdisk, temp);
}
}
else
{
local += ffblk.ff_fsize;
}
}
done = findnext (&ffblk);
}
total += local;
sprintf (temp, "%8ld KB %8ld KB %s", (total + 1023)/1024, (local + 1023)/1024, path + pos);
outln (temp, strlen (temp));
return (total);
}
void du (void)
{
char vdisk;
char *ptr;
char temp[] = "X:";
char path[256];
get_nextparam();
ptr = get_nextparam();
if (ptr == NULL)
{
temp[0] = (pvoie->vdisk == 8) ? 'P' : pvoie->vdisk + 'A';
ptr = temp;
}
vdisk = pvoie->vdisk;
if ((*(ptr + 1) == ':') && (*(ptr + 2) == '\0'))
{
temp[0] = *ptr;
vdisk = *ptr - 'A';
if (vdisk == 13)
vdisk = 8;
ptr = temp;
}
if (tst_point (ptr))
{
strcpy (path, tot_path (ch_slash (ptr), pvoie->dos_path));
parcours (vdisk, path);
retour_dir (vdisk);
}
else
retour_dos ();
}
fbb-7.0.11/src/mbl_prn.c 0000664 0001750 0001750 00000013632 13613525371 011653 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
/*
* MBL_PRN.C
*/
#include
#ifdef __FBBDOS__
static char print_name[128];
static int print_string (char *, FILE *);
#endif
static int open_print (void);
static int print_mess (int, bullist *);
#ifdef __FBBDOS__
static void print_file (char *ptr);
#endif
int mbl_print (void)
{
bullist *pbul;
long no;
int ok = 0;
int verbose = 0;
int old_print = print;
if (voiecur != CONSOLE)
return (0);
incindd ();
if (!ISGRAPH (*indd))
{
if (print)
{
close_print ();
}
else
{
open_print ();
}
return (1);
}
#ifdef __FBBDOS__
if (*indd == '>')
{
incindd ();
print_file (indd);
return (1);
}
#endif
if (toupper (*indd) == 'V')
{
verbose = 1;
incindd ();
}
if (!print)
open_print ();
while ((no = lit_chiffre (1)) != 0L)
{
ok = 1;
if ((pbul = ch_record (NULL, no, '\0')) != NULL)
{
if (!print_mess (verbose, pbul))
break;
}
else
texte (T_ERR + 10);
}
if (!old_print)
close_print ();
return (ok);
}
static int print_mess (int verbose, bullist * pbul)
{
#ifdef __FBBDOS__
char *ptr;
FILE *fptr;
int fd;
int c, first = 1;
int nb = 0;
int call = 0;
char ligne[90];
char chaine[256];
int flag = FALSE;
long record = 0L;
short postexte = 0;
trait_time = 0;
*ptmes = *pbul;
if (*ptmes->bbsv)
sprintf (varx[0], "@%-6s ", ptmes->bbsv);
else
*varx[0] = '\0';
fputc ('\r', file_prn);
if (!print)
return (0);
fputc ('\n', file_prn);
if (!print)
return (0);
ptr = expand (langue[vlang]->plang[T_MBL + 35 - 1]);
if (!print_string (ptr, file_prn))
return (0);
ptr = expand (langue[vlang]->plang[T_MBL + 38 - 1]);
if (!print_string (ptr, file_prn))
return (0);
if ((fptr = fopen (mess_name (MESS, ptmes->numero, chaine), "rb")) == NULL)
return (0);
if (!verbose)
{
/* fseek(fptr, supp_header(fptr, 0), 0) ; */
ptr = ligne;
while ((c = fgetc (fptr)) != EOF)
{
if ((flag) && (c == '\n'))
{
record = ftell (fptr);
postexte = 0;
call = 0;
flag = FALSE;
}
else
{
switch (call)
{
case 0:
break;
case 1:
if (isalnum (c))
{
*ptr++ = c;
nb++;
call = 2;
}
break;
case 2:
if (isalnum (c))
{
*ptr++ = c;
nb++;
}
else
{
*ptr++ = '!';
nb++;
call = 0;
if (nb >= 65)
{
*ptr++ = '\r';
*ptr++ = '\n';
nb += 2;
fflush (file_prn);
write (fileno (file_prn), ligne, nb);
nb = 0;
ptr = ligne;
first = 2;
}
}
break;
}
if (postexte == 0)
{
if (c != 'R') /*return(record) */
break;
else
flag = TRUE;
}
if ((postexte == 1) && (flag) && (c != ':')) /*return(record) */
break;
++postexte;
}
if ((flag) && (c == '@'))
{
if (first)
{
fflush (file_prn);
if (first == 1)
{
write (fileno (file_prn), "Path: !", 7);
}
else
{
write (fileno (file_prn), " !", 7);
}
first = 0;
}
call = 1;
}
}
if (nb)
{
*ptr++ = '\r';
*ptr++ = '\n';
nb += 2;
fflush (file_prn);
write (fileno (file_prn), ligne, nb);
}
}
if (!print)
return (0);
fseek (fptr, record, 0);
fflush (fptr);
fflush (file_prn);
fd = fileno (fptr);
copy_fic (fd, fileno (file_prn), NULL);
fclose (fptr);
#endif
return (1);
}
#ifdef __FBBDOS__
static int print_string (char *ptr, FILE * fptr)
{
while (*ptr)
{
if (*ptr == '\n')
{
fputc ('\r', fptr);
if (!print)
return (0);
}
fputc (*ptr, fptr);
if (!print)
return (0);
++ptr;
}
return (1);
}
#endif
void init_print (void)
{
#ifdef __FBBDOS__
file_prn = stdprn;
strcpy (print_name, "PRN:");
#endif
}
#ifdef __FBBDOS__
static void print_file (char *ptr)
{
char old[128];
char s[256];
int ok = print;
sup_ln (ptr);
if (*ptr)
{
strcpy (old, print_name);
close_print ();
if (*ptr == '-')
{
file_prn = stdprn;
strcpy (print_name, "PRN:");
}
else
{
strcpy (print_name, strupr (ptr));
}
ok = open_print ();
print = 0;
if (!ok)
{
#ifdef ENGLISH
sprintf (s, "Error printing to %s ", print_name);
#else
sprintf (s, "Erreur impression sur %s", print_name);
#endif
strcpy (print_name, old);
}
}
#ifdef ENGLISH
sprintf (s, "Printing to %s ", print_name);
#else
sprintf (s, "Impression sur %s", print_name);
#endif
outln (s, strlen (s));
print = ok;
}
#endif
void close_print (void)
{
print = 0;
#if defined( __WINDOWS__) || defined(__linux__)
SpoolLine (0, 0, NULL, 0);
#endif
#ifdef __FBBDOS__
if ((file_prn != stdprn) && (file_prn))
{
fclose (file_prn);
}
file_prn = NULL;
trait (0, "");
#endif
}
static int open_print (void)
{
#ifdef __linux__
print = 1;
#endif
#ifdef __WINDOWS__
print = 1;
#endif
#ifdef __FBBDOS__
if (file_prn)
close_print ();
if (strcmp (print_name, "PRN:") == 0)
{
print = 1;
file_prn = stdprn;
}
else if ((file_prn = fopen (print_name, "ab")) != NULL)
{
print = 1;
}
trait (0, "");
#endif
return (print);
}
fbb-7.0.11/src/fbb_orb.c 0000664 0001750 0001750 00000071251 13747776632 011636 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
/*
* Serveur de communication socket pour connection console
*
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define WAITINFO 0
#define WAITPASS 1
#define CONNECTED 2
#define DISCONNECT 3
extern void process (void);
void orb_services (void);
static void set_opt(char *command, char *value);
/* extern void usleep(unsigned long); */
static int orb_fd = -1;
typedef struct _OrbClient
{
int fd;
int state;
int monitor;
int channel;
int options;
int infos;
long mask;
time_t cle;
char callsign[12];
struct _OrbClient *next;
}
OrbClient;
static OrbClient *client_head = NULL;
static OrbClient *orb_add_client (void)
{
OrbClient *sptr;
sptr = calloc (1, sizeof (OrbClient));
if (sptr == NULL)
return (NULL);
sptr->next = client_head;
client_head = sptr;
return (sptr);
}
static void orb_del_client (OrbClient * cptr)
{
OrbClient *sptr;
OrbClient *prev;
prev = NULL;
sptr = client_head;
while (sptr)
{
if (sptr == cptr)
{
if (prev)
prev->next = sptr->next;
else
client_head = sptr->next;
free (sptr);
break;
}
prev = sptr;
sptr = sptr->next;
}
}
static int orb_new_connection (int fd)
{
unsigned addr_len;
struct sockaddr_in sock_addr;
memset(&sock_addr, 0x00, sizeof(struct sockaddr_in));
OrbClient *sptr;
sptr = orb_add_client ();
addr_len = sizeof (sock_addr);
sptr->fd = accept (fd, (struct sockaddr *) &sock_addr, &addr_len);
sptr->state = WAITINFO;
return (sptr->fd);
}
static int send_data(int sock, char *datafile, char *datarequest, int len, int command)
{
int fd;
int nb;
char buffer[1024];
memset(buffer, 0x00, sizeof(buffer));
buffer[0] = ORB_DATA;
buffer[1] = command;
buffer[2] = len % 256;
buffer[3] = len >> 8;
memcpy(buffer+4, datarequest, len);
write(sock, buffer, len+4);
fd = open(datafile, O_RDONLY);
if (fd == -1)
{
buffer[2] = 0;
buffer[3] = 0;
write(sock, buffer, 4);
return errno;
}
for (;;)
{
nb = read(fd, buffer+4, 1000);
if (nb < 0)
nb = 0;
buffer[2] = nb % 256;
buffer[3] = nb >> 8;
write(sock, buffer, nb+4);
printf("%d data sent\n", nb);
if (nb == 0)
break;
}
close(fd);
unlink(datafile);
return 0;
}
static long flength(char *filename)
{
struct stat bstat;
memset(&bstat, 0x00, sizeof(struct stat));
if (stat(filename, &bstat) == -1)
return 0L;
return bstat.st_size;
}
static int send_data_buf(OrbClient * sptr, int service, char *command, char *data, int datalen)
{
char buffer[1024];
int length;
memset(buffer, 0x00, sizeof(buffer));
length = strlen(command);
strcpy(buffer+4, command);
if ((length + datalen + 4) > 1024)
return -1;
if (datalen)
{
memcpy(buffer+4+length, data, datalen);
length += datalen;
}
buffer[0] = ORB_DATA;
buffer[1] = service;
buffer[2] = length & 0xff;
buffer[3] = length >> 8;
write(sptr->fd, buffer, 4+length);
return length;
}
static void orb_process_data (OrbClient * sptr)
{
int i, j;
int nb;
int lg;
static char buffer[1024];
static char datafile[256];
static char datarequest[1024];
static int nbrcv = 0;
static int rcv_fd;
static int rcv_state = 0;
char call[256];
char pass[256];
char *ptr;
memset(buffer, 0x00, sizeof(buffer));
memset(datafile, 0x00, sizeof(datafile));
memset(datarequest, 0x00, sizeof(datarequest));
memset(call, 0x00, sizeof(call));
memset(pass, 0x00, sizeof(pass));
lg = 0;
nb = read (sptr->fd, buffer + nbrcv, sizeof (buffer) - nbrcv);
if (nb == -1)
return;
if (nb == 0)
{
editor = 0;
/* Client is disconnected */
if (sptr->mask & ORB_CONSOLE)
{
/* Disconnect from console */
deconnexion (CONSOLE, 0);
}
else
{
close (sptr->fd);
orb_del_client (sptr);
}
nbrcv = 0;
return;
}
nbrcv += nb;
again:
if ((nbrcv >= 3) && (buffer[0] == ORB_REQUEST))
{
unsigned int len;
int mask;
int old_mask = sptr->mask;
int ack;
char cmd[300];
memset(cmd, 0x00, sizeof(cmd));
/*commande */
switch (buffer[1])
{
case 0:
/* Changement de masque */
mask = buffer[2] & 0xff;
ack = 0;
if ((mask & ORB_CONSOLE) != (sptr->mask & ORB_CONSOLE))
{
if (mask & ORB_CONSOLE)
{
FILE *fptr;
if ((fptr = fopen (d_disque ("etat.sys"), "r+t")) != NULL)
{
fprintf (fptr, "%-6s-%X\n",
cons_call.call, cons_call.num);
ferme (fptr, 74);
}
/* Console connection */
if (v_tell && connect_tell ())
{
music (0);
ack = 1;
}
else if (!connect_console ())
{
ack = 2;
}
else
{
ack = 1;
}
}
else
{
/* Console deconnection */
deconnexion (CONSOLE, 0);
ack = 0;
nbrcv = 0;
return;
}
buffer[0] = ORB_XFBBX;
buffer[1] = 0;
buffer[2] = 1;
buffer[3] = 0;
buffer[4] = ack;
write (sptr->fd, buffer, 5);
}
if (ack != 2) /* Don't update mask if connection refused */
{
sptr->mask = mask;
if ((mask & ORB_MSGS) != (old_mask & ORB_MSGS))
{
reset_msgs ();
aff_msg_cons ();
}
if ((mask & ORB_STATUS) != (old_mask & ORB_STATUS))
{
FbbMem (1);
test_pactor(1);
}
if ((mask & ORB_NBCNX) != (old_mask & ORB_NBCNX))
fbb_list (1);
if ((mask & ORB_LISTCNX) != (old_mask & ORB_LISTCNX))
fbb_list (1);
}
lg = 3;
break;
case SVC_DIR:
/* Dir request */
if (nbrcv < 4)
return;
len = ((unsigned int) buffer[3] << 8) + (unsigned int) buffer[2];
if (nbrcv < len+4)
return;
if (sptr->state != CONNECTED)
return;
if (len < 256)
{
int nb;
buffer[nbrcv] = '\0';
sprintf(datafile, "%sclientdata.txt", back2slash(DATADIR));
nb = 1+sprintf(datarequest, "%s%s", back2slash(CONFDIR), buffer+4);
sprintf(cmd, "ls -oA %s | awk '{ print substr($1,1,1),$4,$8,$5\"-\"$6\"-\"$7 }' > %s 2>&1", datarequest, datafile);
printf("system %s\n", cmd);
if (system(cmd) < 0)
perror("orb_process_data() system command execution error");
nb += 1+sprintf(datarequest + nb, "%ld", flength(datafile));
send_data(sptr->fd, datafile, datarequest, nb, SVC_DIR);
}
lg = len+4;
break;
case SVC_RECV:
/* File request */
if (nbrcv < 4)
return;
len = ((unsigned int) buffer[3] << 8) + (unsigned int) buffer[2];
if (nbrcv < len+4)
return;
if (sptr->state != CONNECTED)
return;
if (len < 256)
{
buffer[nbrcv] = '\0';
sprintf(datafile, "%sclientdata.txt", back2slash(DATADIR));
nb = 1+sprintf(datarequest, "%s%s", back2slash(CONFDIR), buffer+4);
sprintf(cmd, "cp %s %s", datarequest, datafile);
printf("system %s\n", cmd);
if (system(cmd) < 0)
perror("orb_process_data() system command execution error");
nb += 1+sprintf(datarequest + nb, "%ld", flength(datafile));
send_data(sptr->fd, datafile, datarequest, nb, SVC_RECV);
}
lg = len+4;
break;
case SVC_SEND:
/* File receive */
if (nbrcv < 4)
return;
len = ((unsigned int) buffer[3] << 8) + (unsigned int) buffer[2];
if (nbrcv < len+4)
return;
if (sptr->state != CONNECTED)
return;
if (len <= 1000)
{
switch (rcv_state)
{
case 0 :
buffer[nbrcv] = '\0';
sprintf(datafile, "%sclientdata.txt", back2slash(DATADIR));
sprintf(datarequest, "%s%s", back2slash(CONFDIR), buffer+4);
printf("receiving file %s\n", datafile);
rcv_fd = open(datafile, O_CREAT|O_TRUNC|O_WRONLY, 0666);
rcv_state = 1;
break;
case 1:
if (len == 0)
{
char header[4];
/* End of file */
if (rcv_fd > 0)
{
close(rcv_fd);
sprintf(cmd, "mv %s %s", datafile, datarequest);
printf("system %s\n", cmd);
if (system(cmd) < 0)
perror("orb_process_data() system command execution error");
test_fichiers = 1;
}
header[0] = ORB_DATA;
header[1] = SVC_SEND;
header[2] = 0;
header[3] = 0;
write(sptr->fd, header, 4);
rcv_state = 0;
break;
}
if (rcv_fd > 0)
{
nb = write(rcv_fd, buffer+4, len);
printf("%d data received\n", len);
if (nb <= 0)
{
close(rcv_fd);
rcv_fd = -1;
}
}
break;
}
}
lg = len+4;
break;
case SVC_FWD:
/* Pending forward request */
if (nbrcv < 4)
return;
len = ((unsigned int) buffer[3] << 8) + (unsigned int) buffer[2];
if (nbrcv < len+4)
return;
if (sptr->state != CONNECTED)
return;
if (len < 256)
{
char command[80];
char arg[80];
memset(command, 0x00, sizeof(command));
memset(arg, 0x00, sizeof(arg));
buffer[nbrcv] = '\0';
sscanf(buffer+4, "%s %s", command, arg);
if (strcasecmp(command, "LIST") == 0)
{
sprintf(datafile, "%sclientdata.txt", back2slash(DATADIR));
strcpy(datarequest, "pending_forward.txt");
nb = 1+sprintf(datarequest, "%s%s", back2slash(CONFDIR), buffer+4);
RequestPendingForward(datafile);
nb += 1+sprintf(datarequest + nb, "%ld", flength(datafile));
send_data(sptr->fd, datafile, datarequest, nb, SVC_FWD);
}
else if (strcasecmp(command, "START") == 0)
{
sprintf(datarequest, "START %s", StartForward(atoi(arg)));
send_data_buf(sptr, SVC_FWD, datarequest, NULL, 0);
}
else if (strcasecmp(command, "STOP") == 0)
{
sprintf(datarequest, "STOP %s", StopForward(atoi(arg)));
send_data_buf(sptr, SVC_FWD, datarequest, NULL, 0);
}
}
lg = len+4;
break;
case SVC_DISC:
/* Disconnect request */
if (nbrcv < 4)
return;
len = ((unsigned int) buffer[3] << 8) + (unsigned int) buffer[2];
if (nbrcv < len+4)
return;
if (sptr->state != CONNECTED)
return;
if (len < 256)
{
char callsign[80];
int nChan;
int bImm;
int nb;
memset(callsign, 0x00, sizeof(callsign));
buffer[nbrcv] = '\0';
nb = sscanf(buffer+4, "%d %s %d", &nChan, callsign, &bImm);
if (nb == 3)
disconnect_channel(nChan, bImm);
}
lg = len+4;
break;
case SVC_USER:
/* users management */
if (nbrcv < 4)
return;
len = ((unsigned int) buffer[3] << 8) + (unsigned int) buffer[2];
if (nbrcv < len+4)
return;
if (sptr->state != CONNECTED)
return;
if (len < 256)
{
int length;
char command[80];
char arg[80];
char *ptr;
memset(command, 0x00, sizeof(command));
memset(arg, 0x00, sizeof(arg));
buffer[nbrcv] = '\0';
sscanf(buffer+4, "%s %s", command, arg);
if (strcasecmp(command, "LIST") == 0)
{
sprintf(datafile, "%sclientdata.txt", back2slash(DATADIR));
strcpy(datarequest, "service.txt");
nb = 1+sprintf(datarequest, "%s%s", back2slash(CONFDIR), buffer+4);
RequestUsersList(datafile);
nb += 1+sprintf(datarequest + nb, "%ld", flength(datafile));
send_data(sptr->fd, datafile, datarequest, nb, SVC_USER);
}
else if (strcasecmp(command, "GET") == 0)
{
ptr = GetUserInfo(arg, &length);
sprintf(datarequest, "USER %s %d\n", arg, length);
send_data_buf(sptr, SVC_USER, datarequest, ptr, length);
}
else if (strcasecmp(command, "PUT") == 0)
{
int datalen = len;
ptr = buffer+4;
while (*ptr && (*ptr != '\n'))
{
++ptr;
--datalen;
}
if (*ptr == '\n')
{
++ptr;
PutUserInfo(arg, ptr, datalen);
ptr = GetUserInfo(arg, &length);
sprintf(datarequest, "USER %s %d\n", arg, length);
send_data_buf(sptr, SVC_USER, datarequest, ptr, length);
}
}
else if (strcasecmp(command, "NEW") == 0)
{
NewUserInfo(arg);
ptr = GetUserInfo(arg, &length);
sprintf(datarequest, "USER %s %d\n", arg, length);
send_data_buf(sptr, SVC_USER, datarequest, ptr, length);
}
else if (strcasecmp(command, "DEL") == 0)
{
DelUserInfo(arg);
}
}
lg = len+4;
break;
case SVC_MSG:
/* messages management */
if (nbrcv < 4)
return;
len = ((unsigned int) buffer[3] << 8) + (unsigned int) buffer[2];
if (nbrcv < len+4)
return;
if (sptr->state != CONNECTED)
return;
if (len < 256)
{
int length;
char command[80];
char arg[80];
char *ptr;
memset(command, 0x00, sizeof(command));
memset(arg, 0x00, sizeof(arg));
buffer[nbrcv] = '\0';
sscanf(buffer+4, "%s %s", command, arg);
if (strcasecmp(command, "LIST") == 0)
{
sprintf(datafile, "%sclientdata.txt", back2slash(DATADIR));
strcpy(datarequest, "service.txt");
nb = 1+sprintf(datarequest, "%s%s", back2slash(CONFDIR), buffer+4);
RequestMsgsList(datafile);
nb += 1+sprintf(datarequest + nb, "%ld", flength(datafile));
send_data(sptr->fd, datafile, datarequest, nb, SVC_MSG);
}
else if (strcasecmp(command, "GET") == 0)
{
ptr = GetMsgInfo(arg, &length);
sprintf(datarequest, "MSG %s %d\n", arg, length);
send_data_buf(sptr, SVC_MSG, datarequest, ptr, length);
}
else if (strcasecmp(command, "PUT") == 0)
{
int datalen = len;
ptr = buffer+4;
while (*ptr && (*ptr != '\n'))
{
++ptr;
--datalen;
}
if (*ptr == '\n')
{
++ptr;
PutMsgInfo(arg, ptr, datalen);
ptr = GetMsgInfo(arg, &length);
sprintf(datarequest, "MSG %s %d\n", arg, length);
send_data_buf(sptr, SVC_MSG, datarequest, ptr, length);
}
}
}
lg = len+4;
break;
case SVC_MREQ:
/* message request */
if (nbrcv < 4)
return;
len = ((unsigned int) buffer[3] << 8) + (unsigned int) buffer[2];
if (nbrcv < len+4)
return;
if (sptr->state != CONNECTED)
return;
if (len < 256)
{
char command[80];
char arg[80];
memset(command, 0x00, sizeof(command));
memset(arg, 0x00, sizeof(arg));
buffer[nbrcv] = '\0';
sscanf(buffer+4, "%s %s", command, arg);
if (strcasecmp(command, "MSG") == 0)
{
sprintf(datafile, "%smessage.txt", back2slash(DATADIR));
mess_name(MESSDIR, atol(arg), datarequest);
nb = 1+strlen(datarequest);
sprintf(cmd, "cp %s %s", datarequest, datafile);
printf("system %s\n", cmd);
if (system(cmd) < 0)
perror("orb_process_data() system command execution error");
nb += 1+sprintf(datarequest + nb, "%ld", flength(datafile));
send_data(sptr->fd, datafile, datarequest, nb, SVC_MREQ);
}
}
lg = len+4;
break;
case SVC_OPT:
/* options management */
if (nbrcv < 4)
return;
len = ((unsigned int) buffer[3] << 8) + (unsigned int) buffer[2];
if (nbrcv < len+4)
return;
if (sptr->state != CONNECTED)
return;
if (len < 256)
{
char command[80];
char arg[80];
char val[80];
memset(command, 0x00, sizeof(command));
memset(arg, 0x00, sizeof(arg));
memset(val, 0x00, sizeof(val));
sptr->options = 1;
buffer[nbrcv] = '\0';
*arg = *val = '\0';
sscanf(buffer+4, "%s %s %s", command, arg, val);
if (strcasecmp(command, "GET") == 0)
{
orb_options();
}
else if (strcasecmp(command, "SET") == 0)
{
set_opt(arg, val);
}
}
lg = len+4;
break;
case SVC_PACTOR:
/* pactor management */
if (nbrcv < 4)
return;
len = ((unsigned int) buffer[3] << 8) + (unsigned int) buffer[2];
if (nbrcv < len+4)
return;
if (sptr->state != CONNECTED)
return;
if (len < 256)
{
char command[80];
int val = 1;
int port = 0;
memset(command, 0x00, sizeof(command));
buffer[nbrcv] = '\0';
sscanf(buffer+4, "%s %d %d", command, &port, &val);
if (strcasecmp(command, "SCAN") == 0)
{
CmdScan(port, val);
}
else if (strcasecmp(command, "CHO") == 0)
{
CmdCHO(port, 1);
}
else if (strcasecmp(command, "BRK") == 0)
{
CmdCHO(port, 0);
}
}
lg = len+4;
break;
case SVC_INFO:
/* channel information */
if (nbrcv < 4)
return;
len = ((unsigned int) buffer[3] << 8) + (unsigned int) buffer[2];
if (nbrcv < len+4)
return;
if (sptr->state != CONNECTED)
return;
if (len < 256)
{
char command[80];
int val = -1;
memset(command, 0x00, sizeof(command));
buffer[nbrcv] = '\0';
sscanf(buffer+4, "%s %d", command, &val);
sptr->infos = (val != -1);
set_info_channel(val);
}
lg = len+4;
break;
default:
if (nbrcv < 4)
return;
len = ((unsigned int) buffer[3] << 8) + (unsigned int) buffer[2];
if (nbrcv < len+4)
return;
lg = len+4;
break;
}
}
else
{
char *endptr;
/* Check if the whole line is received */
buffer[nbrcv] = '\0';
endptr = strrchr (buffer, '\n');
if (endptr == NULL)
return;
editor = 0;
lg = 1 + endptr - buffer;
switch (sptr->state)
{
case WAITINFO:
/* Mask of services */
sscanf (buffer, "%ld %d %s", &sptr->mask, &sptr->channel, call);
call[11] = '\0';
strcpy (sptr->callsign, call);
sptr->cle = time (NULL);
sprintf (call, "%010ld", sptr->cle);
write (sptr->fd, call, strlen (call));
sptr->state = WAITPASS;
break;
case WAITPASS:
/* Callsign sans SSID */
strcpy (call, sptr->callsign);
if ((ptr = strchr (call, '-')))
*ptr = '\0';
/* Password */
sscanf (buffer, "%s", pass);
if (comp_passwd (call, pass, sptr->cle))
{
orb_services();
cons_call.num = extind (strupr (sptr->callsign), cons_call.call);
reset_msgs ();
FbbMem (1);
aff_msg_cons ();
fbb_list (1);
test_pactor(1);
if (sptr->mask & ORB_CONSOLE)
{
FILE *fptr;
if ((fptr = fopen (d_disque ("etat.sys"), "r+t")) != NULL)
{
fprintf (fptr, "%-6s-%X\n",
cons_call.call, cons_call.num);
ferme (fptr, 74);
}
/* Console connection */
if (v_tell && connect_tell ())
{
music (0);
}
else if (!connect_console ())
{
char *txt = "Console already connected !\n\n";
int len = strlen (txt) + 3;
strcpy (buffer + 7, txt);
/* Header */
buffer[0] = ORB_CONSOLE;
buffer[1] = 0;
buffer[2] = (len) & 0xff;
buffer[3] = (len) >> 8;
buffer[4] = CONSOLE;
buffer[5] = W_CNST;
buffer[6] = 0;
write (sptr->fd, buffer, len + 4);
close (sptr->fd);
orb_del_client (sptr);
break; /* F6BVP */
}
}
sptr->state = CONNECTED;
rcv_state = 0;
}
else
{
char *txt = "Callsign/Password error !\n\n";
int len = strlen (txt) + 3;
strcpy (buffer + 7, txt);
/* Header */
buffer[0] = ORB_CONSOLE;
buffer[1] = 0;
buffer[2] = (len) & 0xff;
buffer[3] = (len) >> 8;
buffer[4] = CONSOLE;
buffer[5] = W_CNST;
buffer[6] = 0;
write (sptr->fd, buffer, len + 4);
close (sptr->fd);
orb_del_client (sptr);
}
break;
case CONNECTED:
if (sptr->mask & ORB_CONSOLE)
{
for (i = 0, j = 0; i < nbrcv; i++)
{
if (buffer[i] == '\r')
continue;
if (buffer[i] == '\n')
buffer[j++] = '\r';
else
buffer[j++] = buffer[i];
}
console_inbuf (buffer, j);
}
break;
}
}
if (lg < nbrcv)
{
nbrcv -= lg;
memmove(buffer, buffer+lg, nbrcv);
goto again;
}
nbrcv = 0;
}
static void orb_process (void)
{
int nb;
int maxfd;
fd_set tcp_read;
fd_set tcp_write;
fd_set tcp_excep;
struct timeval to;
OrbClient *sptr;
if (orb_fd == -1)
return;
to.tv_sec = to.tv_usec = 0;
FD_ZERO (&tcp_read);
FD_ZERO (&tcp_write);
FD_ZERO (&tcp_excep);
maxfd = orb_fd;
FD_SET (orb_fd, &tcp_read);
sptr = client_head;
while (sptr)
{
FD_SET (sptr->fd, &tcp_read);
if (sptr->fd > maxfd)
maxfd = sptr->fd;
sptr = sptr->next;
}
nb = select (maxfd + 1, &tcp_read, NULL, NULL, &to);
if (nb == -1)
{
perror ("orb_select");
return;
}
if (nb == 0)
{
/* nothing to do */
return;
}
/* To avoid network locks */
alarm(60);
if (FD_ISSET (orb_fd, &tcp_read))
{
/* New client connection */
orb_new_connection (orb_fd);
}
sptr = client_head;
while (sptr)
{
/* On sauvegarde le next car le pointeur de client peut etre
* libere pendant le traitement en cas de deconnexion */
OrbClient *ptemp = sptr->next;
if (FD_ISSET (sptr->fd, &tcp_read))
{
orb_process_data (sptr);
is_idle = 0;
}
sptr = ptemp;
}
alarm(0);
return;
}
int fbb_orb (char *service, int port)
{
int val;
int len;
struct sockaddr_in sock_addr;
memset(&sock_addr, 0x00, sizeof(struct sockaddr_in));
if ((orb_fd = socket (AF_INET, SOCK_STREAM, 0)) < 0)
{
perror ("socket_r");
return (0);
}
val = 1;
len = sizeof (val);
if (setsockopt (orb_fd, SOL_SOCKET, SO_REUSEADDR, (char *) &val, len) == -1)
{
perror ("opn_tcp : setsockopt SO_REUSEADDR");
}
sock_addr.sin_family = AF_INET;
sock_addr.sin_addr.s_addr = 0;
sock_addr.sin_port = htons (port);
if (bind (orb_fd, (struct sockaddr *) &sock_addr, sizeof (sock_addr)) != 0)
{
perror ("opn_tcp : bind");
close (orb_fd);
return (0);
}
if (listen (orb_fd, SOMAXCONN) == -1)
{
perror ("listen");
close (orb_fd);
return (0);
}
fprintf (stderr, "xfbbC/X server running ...\n");
fprintf (stderr, "xfbbd ready and running ...\n");
fflush (stderr);
for (;;)
{
orb_process ();
process ();
if (is_idle)
{
usleep (1);
}
else
{
is_idle = 1;
}
}
return 1;
}
static void orb_send_data (char *buffer, int lg, int mask)
{
OrbClient *sptr = client_head;
while (sptr)
{
if (sptr->mask & mask)
{
switch (mask)
{
case ORB_MONITOR:
case ORB_CONSOLE:
case ORB_CHANNEL:
if (((mask == ORB_MONITOR) && (buffer[4] == 0xff)) ||
((mask == ORB_CONSOLE) && (buffer[4] == 0)))
{
write (sptr->fd, buffer, lg);
}
/* if ((mask == ORB_CHANNEL) && (buffer[4] > 0) && (buffer[4] < 0xff)) */
if (mask == ORB_CHANNEL)
{
if ((sptr->channel == 0) || (sptr->channel == buffer[4]))
write (sptr->fd, buffer, lg);
}
break;
case ORB_XFBBX:
if (sptr->mask & ORB_CONSOLE)
write (sptr->fd, buffer, lg);
break;
default:
write (sptr->fd, buffer, lg);
break;
}
}
sptr = sptr->next;
}
}
void orb_write (int channel, char *data, int len, int color, int header)
{
int i, j;
char *buffer;
buffer = calloc ((len + 8), sizeof (char));
if (buffer == NULL)
return;
for (i = 0, j = 7; i < len; i++)
{
if (data[i] == '\n')
continue;
if (data[i] == '\r')
buffer[j++] = '\n';
else
buffer[j++] = data[i];
}
if (channel == CONSOLE)
{
/* Editor request ? */
if (editor_request)
{
int len = 1;
char buf[80];
memset(buf, 0, sizeof(buf));
editor_request = 0;
editor = 1;
buf[0] = ORB_XFBBX;
buf[1] = 0;
buf[3] = 0;
switch (reply)
{
case 1 : /* SR */
len += sprintf(buf+5, "%ld", svoie[CONSOLE]->enrcur);
buf[4] = 4;
break;
case 3 : /* Sx */
buf[4] = 3;
break;
default:
buf[4] = 0;
break;
}
buf[2] = len;
orb_send_data (buf, 4+len, ORB_XFBBX);
}
/* Header */
buffer[0] = ORB_CONSOLE;
buffer[1] = 0;
buffer[2] = (j - 4) & 0xff;
buffer[3] = (j - 4) >> 8;
/* Envoie les data de console au client */
buffer[4] = CONSOLE;
buffer[5] = color;
buffer[6] = header;
orb_send_data (buffer, j, ORB_CONSOLE);
}
else if (channel == MMONITOR)
{
/* Header */
buffer[0] = ORB_MONITOR;
buffer[1] = 0;
buffer[2] = (j - 4) & 0xff;
buffer[3] = (j - 4) >> 8;
/* Envoie les data de monitoring au client */
buffer[4] = 0xff;
buffer[5] = color;
buffer[6] = header;
orb_send_data (buffer, j, ORB_MONITOR);
}
else
{
/* Header */
buffer[0] = ORB_CHANNEL;
buffer[1] = 0;
buffer[2] = (j - 4) & 0xff;
buffer[3] = (j - 4) >> 8;
/* Envoie les data de monitoring au client */
buffer[4] = channel - 1;
buffer[5] = color;
buffer[6] = header;
orb_send_data (buffer, j, ORB_CHANNEL);
}
free (buffer);
}
void orb_disc (void)
{
OrbClient *sptr = client_head;
/* Deconnecte un client */
while (sptr)
{
if (sptr->mask & ORB_CONSOLE)
{
if (sptr->mask & ORB_XFBBX)
{
char buffer[5];
/* Envoie la commande de deconnection */
buffer[0] = ORB_XFBBX;
buffer[1] = 0;
buffer[2] = 1;
buffer[3] = 0;
buffer[4] = 0;
write (sptr->fd, buffer, 5);
sptr->mask &= ~ORB_CONSOLE;
}
else
{
close (sptr->fd);
orb_del_client (sptr);
}
break;
}
sptr = sptr->next;
}
}
void orb_services (void)
{
char buffer[260];
int i;
memset(buffer, 0, sizeof(buffer));
/* Header */
buffer[0] = ORB_DATA;
buffer[1] = SVC_LIST;
buffer[2] = SVC_MAX-1; /* Max 255 services */
buffer[3] = 0;
/* One service per byte */
for (i = 1 ; i < SVC_MAX ; i++)
buffer[4 + i - 1] = i;
orb_send_data (buffer, 4 + SVC_MAX - 1, 0xffff);
}
void orb_con_list (int channel, char *ligne)
{
char buffer[256];
int len = strlen (ligne);
memset(buffer, 0, sizeof(buffer));
/* Header */
buffer[0] = ORB_LISTCNX;
buffer[1] = 0;
buffer[2] = (len) & 0xff;
buffer[3] = (len) >> 8;
/* Envoie la ligne de connection du canal */
strcpy (buffer + 4, ligne);
orb_send_data (buffer, len + 4, ORB_LISTCNX);
}
void orb_pactor_status(int port, int p_status)
{
char buffer[80];
int len;
sprintf (buffer + 4, "%d %d", port, p_status);
len = strlen (buffer + 4);
/* Header */
buffer[0] = ORB_DATA;
buffer[1] = SVC_PACTOR;
buffer[2] = (len) & 0xff;
buffer[3] = (len) >> 8;
/* Send pactor status */
orb_send_data (buffer, len + 4, ORB_STATUS);
}
void orb_con_nb (int nb)
{
char buffer[80];
int len;
memset(buffer, 0, sizeof(buffer));
sprintf (buffer + 4, "%d", nb);
len = strlen (buffer + 4);
/* Header */
buffer[0] = ORB_NBCNX;
buffer[1] = 0;
buffer[2] = (len) & 0xff;
buffer[3] = (len) >> 8;
/* Envoie le nombre de connections */
orb_send_data (buffer, len + 4, ORB_NBCNX);
}
void orb_nb_msg (int priv, int hold, int nbmess)
{
char buffer[80];
int len;
memset(buffer, 0, sizeof(buffer));
sprintf (buffer + 4, "%d %d %d", priv, hold, nbmess);
len = strlen (buffer + 4);
/* Header */
buffer[0] = ORB_MSGS;
buffer[1] = 0;
buffer[2] = (len) & 0xff;
buffer[3] = (len) >> 8;
/* Envoie le nombre de messages */
orb_send_data (buffer, len + 4, ORB_MSGS);
}
void orb_status (long lmem, long gmem, long disk1, long disk2)
{
char buffer[80];
int len;
memset(buffer, 0, sizeof(buffer));
sprintf (buffer + 4, "%ld %ld %ld %ld", lmem, gmem, disk1, disk2);
len = strlen (buffer + 4);
/* Header */
buffer[0] = ORB_STATUS;
buffer[1] = 0;
buffer[2] = (len) & 0xff;
buffer[3] = (len) >> 8;
/* Envoie les infos de status */
orb_send_data (buffer, len + 4, ORB_STATUS);
}
static void set_opt(char *command, char *value)
{
int val = atoi(value);
int ok = 1;
switch(*command)
{
case 'B' :
bip = val;
break;
case 'G' :
gate = val;
break;
case 'M' :
sed = val;
break;
case 'T' :
ok_tell = val;
break;
case 'X' :
aff_inexport = val;
break;
case 'P' :
aff_popsmtp = val;
break;
default :
ok = 0;
break;
}
if (ok)
maj_options();
}
void orb_options(void)
{
OrbClient *sptr = client_head;
char *command = "OPT\n";
char buffer[256];
int nb = 0;
memset(buffer, 0, sizeof(buffer));
nb += sprintf(buffer+nb, "B %d Connection bip\n", (bip) ? 1 : 0);
nb += sprintf(buffer+nb, "G %d Gateway\n", (gate) ? 1 : 0);
nb += sprintf(buffer+nb, "M %d Message Editor\n", (sed) ? 1 : 0);
nb += sprintf(buffer+nb, "T %d Talk\n", (ok_tell) ? 1 : 0);
nb += sprintf(buffer+nb, "X %d Im/export display\n", (aff_inexport) ? 1 : 0);
nb += sprintf(buffer+nb, "P %d POP/SMTP display\n", (aff_popsmtp) ? 1 : 0);
while (sptr)
{
/* Send information only to the right clients */
if (sptr->options)
send_data_buf(sptr, SVC_OPT, command, buffer, nb);
sptr = sptr->next;
}
}
void orb_info(int val, char *str)
{
static char buffer[512];
static int nb = 0;
memset(buffer, 0, sizeof(buffer));
if (str)
{
nb += sprintf(buffer+nb, "%d %s\n", val, str);
}
else if (nb > 0)
{
OrbClient *sptr = client_head;
char *command = "INFO\n";
while (sptr)
{
/* Send information only to the right clients */
if (sptr->infos)
send_data_buf(sptr, SVC_INFO, command, buffer, nb);
sptr = sptr->next;
}
nb = 0;
}
}
fbb-7.0.11/src/fwdovl4.c 0000664 0001750 0001750 00000030772 13615565522 011617 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
/*
* MODULE FORWARDING OVERLAY 4
*/
#include
static long t_msg_fwd_suiv (int, uchar, uchar, uchar, int, char *);
#ifdef __FBBDOS__
static char *expand_path (char *cmde)
{
struct stat statbuf;
char str[256];
char *path;
/* Cherche en direct */
if (stat (cmde, &statbuf) == 0)
{
path = cmde;
return (path);
}
sprintf (str, "%s.EXE", cmde);
if (stat (str, &statbuf) == 0)
{
path = str;
return (path);
}
sprintf (str, "%s.COM", cmde);
if (stat (str, &statbuf) == 0)
{
path = str;
return (path);
}
sprintf (str, "%s.BAT", cmde);
if (stat (str, &statbuf) == 0)
{
path = str;
return (path);
}
/* Cherche avec le path */
path = searchpath (cmde);
if (path == NULL)
{
sprintf (str, "%s.EXE", cmde);
path = searchpath (str);
}
if (path == NULL)
{
sprintf (str, "%s.COM", cmde);
path = searchpath (str);
}
if (path == NULL)
{
sprintf (str, "%s.BAT", cmde);
path = searchpath (str);
}
/*
if (path == NULL)
{
dprintf("Pas trouve {%s}\n", str);
}
*/
return (path);
}
#endif
/*
* send_dos : envoie une commande MsDos
*
* Type = 0 :
* 1 : Sauvegarde la fenetre BBS et affiche le message d'erreur
* 2 : Affiche le message d'erreur
* 3 : Pas d'affichage, de sauvegarde et de retour.
* 4 : Redirige les sorties sur EXECUTE.$$$ et retourne le contenu
* 5 : Sauvegarde de la fenetre, pas d'affichage et de retour.
*/
int send_dos (int type, char *commande, char *data)
{
#ifdef __linux__
return (-1);
#endif
#ifdef __WINDOWS__
int err;
char log[256];
strcpy (log, commande);
if (data)
{
strcat (log, " ");
strcat (log, data);
}
err = fbb_exec (log);
return (err);
#endif
#ifdef __FBBDOS__
static char option[] = "/C";
char *arg[40];
char log[256];
char deroute[80];
char *path;
int duplic, oldstdout, oldstderr;
int err, i = 0;
fen *sav_fen;
int errtemp;
int disk;
int ofst;
char cur_dir[MAXPATH];
int n;
if (!*commande)
return (0);
log[0] = (type == 1) ? 'D' : 'X';
log[1] = ' ';
strn_cpy (70, log + 2, commande);
fbb_log (voiecur, 'D', log);
arg[i++] = getenv ("COMSPEC");
arg[i++] = option;
arg[i++] = strtok (commande, " ");
while ((arg[i] = strtok (NULL, " ")) != NULL)
++i;
if (data)
{
arg[i++] = data;
arg[i] = NULL;
}
path = expand_path (arg[2]);
if (path == NULL)
return (-1);
arg[2] = path;
ofst = 2;
if (strstr (arg[2], ".BAT"))
{
ofst = 0;
}
deb_io ();
disk = getdisk ();
strcpy (cur_dir, "X:\\");
cur_dir[0] = 'A' + disk;
getcurdir (0, cur_dir + 3);
operationnel = FALSE;
if ((type == 1) || (type == 5))
{
sav_fen = create_win (1, 1, 80, h_screen);
if (EGA)
ega_close ();
puttxt (fen_dos);
puttext_info (&(fen_dos->sav_mod));
break_ok ();
err = spawnv (P_WAIT, arg[ofst], arg + ofst);
if (err == -1)
{
ofst = 0;
err = spawnv (P_WAIT, arg[ofst], arg + ofst);
}
break_stop ();
errtemp = errno;
gettext_info (&(fen_dos->sav_mod));
gettxt (1, 1, 80, 25, fen_dos->ptr);
if (EGA)
ega_open ();
close_win (sav_fen);
}
else
{
if (type == 4)
{
/* redirige stdout et stderr sur le fichier EXECUTE.$$$ */
sprintf (deroute, "%s\\EXECUTE.$$$", getcwd (log, 80));
duplic = open (deroute, O_CREAT | O_RDWR, S_IWRITE | S_IREAD);
}
else
{
duplic = open ("NUL", O_WRONLY, S_IWRITE | S_IREAD);
}
oldstdout = dup (1);
oldstderr = dup (2);
dup2 (duplic, 1);
dup2 (duplic, 2);
close (duplic);
break_ok ();
err = spawnv (P_WAIT, arg[ofst], arg + ofst);
if (err == -1)
{
ofst = 0;
err = spawnv (P_WAIT, arg[ofst], arg + ofst);
}
break_stop ();
errtemp = errno;
dup2 (oldstdout, 1);
dup2 (oldstderr, 2);
close (oldstdout);
close (oldstderr);
if (type == 4)
{
if (err != -1)
{
outfich (deroute);
}
unlink (deroute);
}
}
operationnel = TRUE;
setdisk (disk);
chdir (cur_dir);
if ((type < 3) && (err == -1))
{
strcpy (log, "DOS Error : ");
for (n = ofst; n < i; n++)
{
strcat (log, arg[n]);
strcat (log, " ");
}
errno = errtemp;
perror (log);
}
fin_io ();
return (err);
#endif
}
/* ok_fwd = 0 -> Le message n'est pas marque 'F' */
/* Si nobbs = 0 -> raz flags fwd */
void sup_fwd (long num, int ok_fwd, uchar nobbs)
{
int i, pos, mode;
int del = 0;
unsigned num_indic;
bullist bul;
ind_noeud *noeud;
mess_noeud *mptr;
lfwd *ptr_fwd = tete_fwd;
recfwd *prec = NULL;
pos = 0;
deb_io ();
while (1)
{
if (pos == NBFWD)
{
ptr_fwd = ptr_fwd->suite;
if (ptr_fwd == NULL)
break;
pos = 0;
}
prec = &ptr_fwd->fwd[pos];
if (prec->nomess == num)
break;
pos++;
}
if ((mptr = findmess (num)) != NULL)
{
ouvre_dir ();
read_dir (mptr->noenr, &bul);
if (nobbs <= NBBBS)
{
if (nobbs)
{
/* Bulletin : Marque la BBS */
clr_bit_fwd (prec->fbbs, nobbs);
clr_bit_fwd (bul.fbbs, nobbs);
set_bit_fwd (bul.forw, nobbs);
}
else
{
/* Prive : Marque et supprime les autres routes */
for (i = 0; i < NBMASK; i++)
{
bul.forw[i] = bul.fbbs[i];
bul.fbbs[i] = '\0';
}
/* Supprime le MID */
if (del)
delete_bid (bul.bid);
}
}
/* Supprime le message binaire si forwarde */
if (!fwd_mask (bul.fbbs))
{
if (ok_fwd)
{
noeud = insnoeud (bul.desti, &num_indic);
if (bul.status == 'N')
--(noeud->nbnew);
bul.status = 'F';
}
prec->type = '\0';
prec->bin = '\0';
mode = pvoie->binary;
set_binary (voiecur, 1);
/************** Verifier si pas en cours d'envoi ! *********************/
del = 1;
for (i = 1; i < NBVOIES; i++)
{
if ((svoie[i]->sta.connect) &&
(i != voiecur) &&
(FOR (svoie[i]->mode)) &&
(svoie[i]->entmes.numero == num))
{
del = 0;
}
}
if (del)
supp_mess (num); /* supprime le fichier binaire eventuellement */
set_binary (voiecur, mode);
aff_msg_cons ();
}
write_dir (mptr->noenr, &bul);
ferme_dir ();
}
else
{
for (i = 0; i < NBMASK; i++)
prec->fbbs[i] = '\0';
}
fin_io ();
}
/* Cherche si le destinataire existe dans la base et route sur son homebbs */
void entete_envoi_fwd (int voie)
{
/* envoie la ligne de commande acheminant message vers bbs */
char s[80];
char type;
char *bbs_v;
if (HIE (svoie[voie]->mode))
bbs_v = svoie[voie]->entmes.bbsv;
else
bbs_v = bbs_via (svoie[voie]->entmes.bbsv);
type = svoie[voie]->entmes.type;
if ((type == 'A') && (!ACQ (svoie[voie]->mode)))
type = 'P';
sprintf (s, "S%c %s", type, svoie[voie]->entmes.desti);
printf ("S%c %s\n", type, svoie[voie]->entmes.desti);
outs (s, strlen (s));
if (*bbs_v)
{
sprintf (s, " @ %s", bbs_v);
outs (s, strlen (s));
}
if (*svoie[voie]->entmes.exped)
{
sprintf (s, " < %s", svoie[voie]->entmes.exped);
outs (s, strlen (s));
}
if (*(svoie[voie]->entmes.bid))
{
if (((svoie[voie]->entmes.status == '$') && (BID (svoie[voie]->mode)))
|| (MID (svoie[voie]->mode)) || (strcmp (svoie[voie]->entmes.desti, "SYSOP") == 0)
)
{
sprintf (s, " $%s", svoie[voie]->entmes.bid);
printf (" $%s\n", svoie[voie]->entmes.bid);
outs (s, strlen (s));
}
}
cr ();
}
void entete_fwd (int voie)
{
char *s;
char header[160];
s = svoie[voie]->entmes.titre;
outsln (s, strlen (s));
deb_io ();
make_header (&(svoie[voie]->entmes), header);
entete_mess_fwd (&(svoie[voie]->entmes), header);
outs (msg_header, strlen (msg_header));
aff_etat ('E');
send_buf (voiecur);
fin_io ();
}
int fin_envoi_fwd (int voie)
{
/* Si Nø de message nul retour */
if (svoie[voie]->entmes.numero == 0L)
return (FALSE);
/* teste si le message est encore a forwarder et enleve de la liste */
if ((svoie[voie]->entmes.status == '$') || (multi_prive))
sup_fwd (svoie[voie]->entmes.numero, TRUE, svoie[voie]->bbsfwd);
else
sup_fwd (svoie[voie]->entmes.numero, TRUE, 0);
return (TRUE);
}
atfwd *attend_fwd (int nobbs, uchar max, uchar old, uchar typ, int data_mode)
{
int pos, noctet, ok = 0;
char cmpmsk;
static atfwd nbmess;
recfwd *prec;
lfwd *ptr_fwd = tete_fwd;
time_t date = time(NULL) - 3600L * (long)old;
pos = 0;
noctet = (nobbs - 1) / 8;
cmpmsk = 1 << ((nobbs - 1) % 8);
nbmess.nbpriv = nbmess.nbbul = nbmess.nbkb = 0;
while (1)
{
if (pos == NBFWD)
{
ptr_fwd = ptr_fwd->suite;
if (ptr_fwd == NULL)
break;
pos = 0;
}
prec = &ptr_fwd->fwd[pos];
pos++;
if (prec->type)
{
if ((data_mode == 0) && (prec->bin))
continue;
if ((data_mode == 3) && (!prec->bin))
continue;
if ((data_mode == 2) && (prec->bin) && (!PRIVATE (prec->type)))
continue;
if ((prec->fbbs[noctet] & cmpmsk) && (prec->date <= date) && (prec->kb <= max))
{
if (PRIVATE (prec->type))
{
++nbmess.nbpriv;
ok = 1;
nbmess.nbkb += prec->kb;
}
else if (!(typ & FWD_PRIV))
{
++nbmess.nbbul;
ok = 1;
nbmess.nbkb += prec->kb;
}
}
}
}
return ((ok) ? &nbmess : NULL);
}
static int is_egal (long numero)
{
int i;
int nb = pvoie->nb_egal;
if (nb > NB_DEL)
nb = NB_DEL;
for (i = 0; i < nb; i++)
{
if (pvoie->mess_egal[i] == numero)
return (1);
}
return (0);
}
int not_in_bloc (long numero, int voie)
{
if (pvoie->niv1 == N_XFWD)
return (not_in_xfwd_mess (numero, voie));
else
return (not_in_fb_mess (numero, voie));
}
static long t_msg_fwd_suiv (int nobbs, uchar max, uchar old, uchar typ, int voie, char *test)
{
int pos, noctet;
int data_mode = svoie[voie]->data_mode;
char cmpmsk;
recfwd *prec;
recfwd *psel;
lfwd *ptr_fwd;
time_t date = time(NULL) - 3600L * (long)old;
noctet = (nobbs - 1) / 8;
cmpmsk = 1 << ((nobbs - 1) % 8);
ptr_fwd = tete_fwd;
psel = NULL;
pos = 0;
while (1)
{
if (pos == NBFWD)
{
ptr_fwd = ptr_fwd->suite;
if (ptr_fwd == NULL)
break;
pos = 0;
}
prec = &ptr_fwd->fwd[pos];
pos++;
/* Message en cours d'edition */
if ((reply == 4) && (svoie[CONSOLE]->enrcur == prec->nomess))
continue;
if ((data_mode == 0) && (prec->bin))
continue;
if ((data_mode == 3) && (!prec->bin))
continue;
if ((data_mode == 2) && (prec->bin) && (!PRIVATE (prec->type)))
continue;
if (is_egal (prec->nomess))
{
continue;
}
if ((prec->type) && (prec->fbbs[noctet] & cmpmsk) &&
(prec->date <= date) && (prec->kb <= max) && (not_in_bloc (prec->nomess, voie)))
{
if (typ & FWD_SMALL)
{
if (PRIVATE (prec->type))
{
if ((!psel) || (!PRIVATE (psel->type)) || (psel->kb > prec->kb))
psel = prec;
}
else if ((!(typ & FWD_PRIV)) && ((!psel) || (!PRIVATE (psel->type))))
{
if ((test == NULL) || (strncmp (test, prec->bbsv, 6) == 0))
{
if ((!psel) || (psel->kb > prec->kb))
psel = prec;
}
}
}
else
{
if (PRIVATE (prec->type))
{
if ((!psel) || (!PRIVATE (psel->type)) || (psel->kb > prec->kb))
/* if ((!psel) || (prec->nomess < psel->nomess)) */
psel = prec;
}
else if ((!(typ & FWD_PRIV)) && ((!psel) || (!PRIVATE (psel->type))))
{
if ((test == NULL) || (strncmp (test, prec->bbsv, 6) == 0))
{
if ((!psel) || (prec->nomess < psel->nomess))
{
psel = prec;
}
}
}
}
}
}
if ((psel) && (typ & FWD_PRIV) && (!PRIVATE (psel->type)))
psel = NULL;
if ((psel) && (!PRIVATE (psel->type)) && (test) && (strncmp (test, psel->bbsv, 6) != 0))
psel = NULL;
return ((psel) ? psel->nomess : 0L);
}
long msg_fwd_suiv (int nobbs, uchar max, uchar old, uchar typ, int voie)
{
int i;
long numero;
for (i = 0; i < NB_P_ROUTE; i++)
{
if (*pvoie->p_route[i])
{
numero = t_msg_fwd_suiv (nobbs, max, old, typ, voie, pvoie->p_route[i]);
if (numero)
{
return (numero);
}
}
else
break;
}
numero = t_msg_fwd_suiv (nobbs, max, old, typ, voie, NULL);
return (numero);
}
fbb-7.0.11/src/serv.c 0000664 0001750 0001750 00000043005 13615322674 011201 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
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
#include
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 ();
#ifdef __MSDOS__
fprintf (stderr, "\nMSDOS defined main() INITIALISATION\n");
initialisations ();
#endif
#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 (int 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;
/*
#ifdef __linux__
close(p_com[voie].comfd);
p_com[voie].comfd = -1; / * libere le port * /
#endif
*/
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 (void)
{
#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);
}
fbb-7.0.11/src/fwdovl6.c 0000664 0001750 0001750 00000033277 14070366623 011621 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
/*
* MODULE FORWARDING OVERLAY 6
*/
#include
static int lit_champ (char *, int, int);
static void lit_fich (char *, int);
void entete_saisie (void)
{
pvoie->msgtete = NULL;
ptmes->taille = 0L;
pvoie->messdate = time (NULL);
pvoie->mess_recu = 0;
pvoie->entete = 1;
pvoie->header = 0;
pvoie->mess_num = -1;
*pvoie->mess_bid = '\0';
strn_cpy (39, pvoie->mess_home, mypath);
del_temp (voiecur);
}
int rcv_titre (void)
{
#define MAX_TITRE 60
int nb = MAX_TITRE;
char *scan;
entete_saisie ();
/* Efface un eventuel fichier existant
*/
scan = ptmes->titre;
while ((*indd) && (*indd != '\n') && (*indd != '\r'))
{
if ((nb) && (*indd != 0x1a))
{
nb--;
*scan++ = *indd;
}
++indd;
}
if (*indd)
++indd;
*scan = '\0';
if ((!FOR (pvoie->mode)) && (nb == MAX_TITRE))
{
texte (T_MBL + 21);
return (0);
}
return (1);
}
static int swap_get (char *buffer)
{
if (*swap_scan == '\032')
return (0);
while ((*buffer++ = *swap_scan++) != '\0');
return (1);
}
static void swapp_champ (bullist * pbul, char *nouveau, char sw_champ)
{
switch (sw_champ)
{
case '@':
strn_cpy (40, pbul->bbsv, nouveau);
break;
case '>':
strn_cpy (6, pbul->desti, nouveau);
break;
case '<':
strn_cpy (6, pbul->exped, nouveau);
break;
}
}
int swapp_bbs (bullist * pbul)
{
char champ;
char sw_champ;
char ligne[81], ancien[80], nouveau[80];
char *optr = nouveau;
int ret = 0;
df ("swapp_bbs", 2);
swap_scan = swap_file;
while (swap_get (ligne))
{
*ancien = *nouveau = '\0';
champ = sw_champ = '\0';
if (sscanf (ligne, "%c%s %c%s\n",
&champ, ancien, &sw_champ, nouveau))
{
optr = nouveau;
if (sw_champ == '\0')
sw_champ = champ;
switch (sw_champ)
{
case '@':
case '>':
case '<':
break;
default:
sprintf (ligne, "%c%s", sw_champ, nouveau);
sw_champ = champ;
optr = ligne;
}
switch (champ)
{
case '@':
/* if (indcmp (pbul->bbsv, ancien)) */
if (hiecmp (pbul->bbsv, ancien))
{
swapp_champ (pbul, optr, sw_champ);
/* ret = 1; */
}
break;
case '>':
if (indcmp (pbul->desti, ancien))
{
swapp_champ (pbul, optr, sw_champ);
/* ret = 1; */
}
break;
case '<':
if (indcmp (pbul->exped, ancien))
{
swapp_champ (pbul, optr, sw_champ);
/* ret = 1; */
}
break;
}
}
if (ret)
{
break;
}
}
/* if (indcmp (mycall, bbs_via (pbul->bbsv))) */
if (hiecmp (mypath, pbul->bbsv))
{
*pbul->bbsv = '\0';
ret = 0;
}
ff ();
return (ret);
}
void ini_champs (int voie)
{
int i;
svoie[voie]->entmes.status = 'N';
svoie[voie]->entmes.type = ' ';
svoie[voie]->entmes.taille = 0L;
svoie[voie]->entmes.bin = 0;
svoie[voie]->m_ack = 0;
svoie[voie]->messdate = time (NULL);
svoie[voie]->mess_num = -1;
svoie[voie]->entmes.numero = 0L;
svoie[voie]->entmes.theme = 0;
*(svoie[voie]->mess_bid) = '\0';
*(svoie[voie]->entmes.desti) = '\0';
*(svoie[voie]->entmes.bbsv) = '\0';
*(svoie[voie]->entmes.bbsf) = '\0';
*(svoie[voie]->entmes.bid) = '\0';
*(svoie[voie]->appendf) = '\0';
for (i = 0; i < NBMASK; i++)
{
svoie[voie]->entmes.fbbs[i] = svoie[voie]->entmes.forw[i] = '\0';
}
strn_cpy (6, svoie[voie]->entmes.exped, svoie[voie]->sta.indicatif.call);
}
int lit_com_fwd (void)
{
ini_champs (voiecur);
return (scan_com_fwd ());
}
int scan_com_fwd (void)
{
char exped[10];
int autotype = 0;
sup_ln (indd);
//strupr (indd);
if (!is_room ())
{
outln ("*** Disk full !", 15);
return (0);
}
if (ISGRAPH (*indd))
{
*indd = toupper (*indd);
if ((*indd == 'T') || (*indd == 'B') || (*indd == 'P') || (FOR (pvoie->mode)) || (BBS (pvoie->finf.flags)))
{
ptmes->type = *indd;
}
else if ((*indd == 'E') || (isdigit (*indd)))
ptmes->type = 'E';
++indd;
}
if (!is_espace (indd))
{
texte (T_ERR + 2);
return (0);
}
incindd ();
if (!lit_champ (ptmes->desti, 6, 1))
return (0);
if (ptmes->type == ' ')
{
if ((find (ptmes->desti)) || (is_serv (ptmes->desti)))
{
ptmes->type = 'P';
}
else
{
ptmes->type = 'B';
}
autotype = 1;
}
if (*indd == ' ')
incindd ();
/* Transforme le 1er "AT" en "@" */
if (strlen (indd) > 3)
{
if ((indd[0] == 'A') && (indd[1] == 'T') && (isspace (indd[2])))
{
indd[0] = '@';
indd[1] = ' ';
}
}
while (*indd)
{
switch (*indd)
{
case '@':
incindd ();
if (!lit_champ (ptmes->bbsv, 31, 2))
return (0);
if (*indd == ' ')
incindd ();
if ((ptmes->type != 'P') &&
(ptmes->type != 'T') &&
(!isdigit (ptmes->type)))
{
ptmes->type = 'B';
}
break;
case '<':
incindd ();
if (!lit_champ (exped, 6, 1))
return (0);
if (*exped)
{
if ((strcmp (exped, pvoie->sta.indicatif.call) != 0) && (!forward_auth (voiecur)))
{
varx[0][0] = '<';
varx[0][1] = '\0';
texte (T_ERR + 9);
return (0);
}
strcpy (ptmes->exped, exped);
}
if (*indd == ' ')
incindd ();
break;
case '+':
if (!droits (ACCESDOS))
{
if (!(FOR (pvoie->mode)))
{
varx[0][0] = '+';
varx[0][1] = '\0';
texte (T_ERR + 9);
}
return (0);
}
incindd ();
lit_fich (pvoie->appendf, 79);
if (access (pvoie->appendf, 0) != 0)
{
texte (T_ERR + 11);
return (FALSE);
}
if (*indd == ' ')
incindd ();
break;
case '$':
incindd ();
if (*indd)
{
if (!lit_champ (ptmes->bid, 12, 0))
return (0);
}
else
sprintf (ptmes->bid, " ");
if (*indd == ' ')
incindd ();
break;
default:
if (*indd != '\r')
{
if (!(FOR (pvoie->mode)))
{
varx[0][0] = *indd;
varx[0][1] = '\0';
texte (T_ERR + 9);
}
return (0);
}
++indd;
break;
}
}
if (*ptmes->desti == '\0')
{
if (!(FOR (pvoie->mode)))
texte (T_ERR + 6);
return (0);
}
/* Prive sur routage de groupe ! */
/* Private callsign check removed for bulletins because of problems with sending
to destinations which validate with the private callsign check (eg. 7PLUS@WW)
Other software also doesn't seem to have this check, tested with BPQmail and JNOS.
*/
/*
if ((*ptmes->bbsv) && (ptmes->type != 'T') &&
(!msg_find (bbs_via (ptmes->bbsv))) && (find (ptmes->desti)))
{
if ((strcmp ("SYSOP", ptmes->desti) != 0) && (strcmp ("WP", ptmes->desti) != 0) && (!(FOR (pvoie->mode))))
{
texte (T_MBL + 21);
return (0);
}
}
*/
ptmes->status = 'N';
if (*ptmes->bbsv)
{
if ((autotype) && (ptmes->type == 'P') && (!find (ptmes->desti)) && (!find (bbs_via (ptmes->bbsv))))
ptmes->type = 'B';
if ((*ptmes->bbsv) &&
(!find (bbs_via (ptmes->bbsv))) &&
(((ptmes->type != 'P') &&
(ptmes->type != 'A')) ||
(strcmp (ptmes->desti, "SYSOP") == 0) || (strcmp ("WP", ptmes->desti) == 0)))
{
ptmes->status = '$';
}
}
swapp_bbs (ptmes);
if ((*ptmes->bbsv == '\0') && (ptmes->type == 'P'))
{
pvoie->m_ack = 1;
}
if (!addr_check (ptmes->bbsv))
{
return (0);
}
if (!reacheminement ())
return (0);
if ((*ptmes->bbsv == '\0') && (ptmes->type == 'A'))
{
ptmes->type = 'P';
}
if (!is_bid (ptmes->bid))
{
return (0);
}
return (1);
}
static int rej_get (char *buffer)
{
if (*rej_scan == '\032')
return (0);
while ((*buffer++ = *rej_scan++) != '\0');
return (1);
}
static int tst_mes_ems (int mode, bullist * ptmes)
{
long taille;
int retour = 0;
unsigned record = 0;
Rej_rec rej;
while (read_rej (record, &rej))
{
if (strchr(rej.mode, mode))
{
taille = (long) rej.size * 1000L;
retour = (
((rej.type == '*') || (rej.type == ptmes->type)) &&
(strmatch (ptmes->exped, rej.exped)) &&
(strmatch (bbs_via (ptmes->bbsv), rej.via)) &&
(strmatch (ptmes->desti, rej.desti)) &&
(strmatch (ptmes->bid, rej.bid)) &&
(ptmes->taille >= taille)
);
if (retour)
{
if (rej.mode[0] == '!')
{
retour = 0;
break;
}
else
break;
}
}
++record;
}
return (retour);
}
static int tst_mes (int mode, bullist * ptmes)
{
if (ptmes->type == 'A')
return (0);
if (EMS_REJ_OK ())
{
return (tst_mes_ems (mode, ptmes));
}
else
{
char chaine[82], smode[20], type[20], exped[20];
char via[50], desti[20], bid[20];
long taille;
int retour = 0;
rej_scan = rej_file;
while (rej_get (chaine))
{
sscanf (chaine, "%s %s %s %s %s %s %ld",
smode, type, exped, via, desti, bid, &taille);
char *s = smode;
while (*s) {
*s = toupper((unsigned char) *s);
s++;
}
if (strchr(smode, mode))
{
taille *= 1000;
retour = (
((type[0] == '*') || (type[0] == ptmes->type)) &&
(strmatch (ptmes->exped, exped)) &&
(strmatch (bbs_via (ptmes->bbsv), via)) &&
(strmatch (ptmes->desti, desti)) &&
(strmatch (ptmes->bid, bid)) &&
(ptmes->taille >= taille)
);
if (retour)
{
if (smode[0] == '!')
{
retour = 0;
break;
}
else
break;
}
}
}
return (retour);
}
}
int rejet (bullist * ptmes)
{
int retour;
retour = tst_mes ('R', ptmes);
if ((svoie[voiecur]->fbb >= 2) || (svoie[voiecur]->mbl_ext))
return ((retour) ? 4 : 0);
else
return ((retour) ? 1 : 0);
}
int retenu (bullist * ptmes)
{
int retour;
retour = tst_mes ('H', ptmes);
if (svoie[voiecur]->fbb >= 2)
return ((retour) ? 5 : 0);
else
return (0);
}
int hold (bullist * ptmes)
{
int retenu = 0;
if ((!pvoie->header) || (pvoie->mode == 0))
{
retenu = tst_mes ('L', ptmes);
}
if (!retenu)
{
retenu = tst_mes ('H', ptmes);
}
return (retenu);
}
/*
* Mode = 0 : Tous caracteres entre 0x21 et 0xff
* Mode = 1 : champ sans '@' ni '.'
* Mode = 2 : champ d'adresse hierarchique sans '@'
*
*/
static int lit_champ (char *champ, int nb, int mode)
{
int i;
int error = 0;
char *str = indd;
char last = '\0';
while ((*indd) && (!isspace (*indd)))
{
if (!ISGRAPH (*indd))
{
error = 1;
break;
}
if (mode == 1)
{
if (((std_header & 1) == 0) && (*indd == '@'))
{
break;
}
if (*indd == '.')
{
error = 1;
break;
}
}
else if (mode == 2)
{
if (*indd == '@')
{
error = 1;
break;
}
}
if (--nb < 0)
break;
*champ++ = toupper(*indd);
last = *indd++;
}
*champ = '\0';
if (nb < 0)
error = 2;
if ((mode == 2) && ((std_header & 2) == 0) && (last == '.'))
error = 1;
if (!error)
return (1);
if (FOR (pvoie->mode))
return (0);
for (i = 0; i < 40; ++str)
{
if (isspace (*str))
break;
varx[0][i++] = toupper (*str);
}
varx[0][i] = '\0';
switch (error)
{
case 1: /* Champ errone */
texte (T_ERR + 17);
break;
case 2: /* Champ trop long */
texte (T_ERR + 16);
break;
}
return (0);
}
static void lit_fich (char *champ, int nb)
{
while ((nb--) && (ISGRAPH (*indd)))
{
*champ++ = *indd++;
}
*champ = '\0';
}
void ch_bbs (int mode, char ifwd[NBBBS][7])
{
int i, bbs, tempif, cptif = 0, nb_fwd = 0;
char nombbs[80];
char combuf[80];
char *pcom;
/* init_bbs() ; */
bbs = 0;
for (i = 0; i < NBMASK * 8; i++)
*ifwd[i] = '\0';
rewind_fwd ();
while (fwd_get (combuf))
{
pcom = combuf;
switch (*pcom++)
{
case 'A': /* recuperer le nom de la BBS destinataire */
strcpy (nombbs, pcom);
bbs = num_bbs (nombbs);
strn_cpy (6, ifwd[bbs - 1], nombbs);
nb_fwd++;
break;
case 'E': /* ENDIF */
if (!mode)
--cptif;
break;
case 'I': /* IF */
if (mode)
break;
++cptif;
if (tst_fwd (pcom, bbs, time (NULL), 0, NULL, 1, -1) == FALSE)
{
tempif = cptif - 1;
while (cptif != tempif)
{
if (fwd_get (combuf) == 0)
{
break;
}
pcom = combuf;
switch (*pcom++)
{
case 'I':
++cptif;
break;
case 'E':
--cptif;
break;
case '@':
if (cptif == (tempif + 1))
++tempif;
break;
default:
break;
}
}
}
break;
case '@': /* ELSE */
if (mode)
break;
if (cptif == 0)
break;
tempif = cptif - 1;
while (cptif != tempif)
{
if (fwd_get (combuf) == 0)
{
break;
}
pcom = combuf;
switch (*pcom++)
{
case 'I':
++cptif;
break;
case 'E':
--cptif;
break;
default:
break;
}
}
break;
default:
break;
}
if (nb_fwd == NBMASK * 8)
break;
}
}
int test_linked (void)
{
strupr (sup_ln (indd));
if ((pvoie->aut_linked) && (strncmp (indd, "LINKED TO ", 10) == 0))
{
strtok (indd, " ");
libere_zones_allouees (voiecur); /* Vide les eventuelles listes */
maj_niv (0, 0, 0);
con_voie (voiecur, indd);
return (1);
}
return (0);
}
void clear_fwd (long numero)
{
recfwd *prec;
int pos = 0;
lfwd *ptr_fwd = tete_fwd;
while (1)
{
if (pos == NBFWD)
{
ptr_fwd = ptr_fwd->suite;
if (ptr_fwd == NULL)
break;
pos = 0;
}
prec = &ptr_fwd->fwd[pos];
if ((prec->type) && (prec->nomess == numero))
{
prec->type = '\0';
break;
}
pos++;
}
}
fbb-7.0.11/src/dos_1.c 0000664 0001750 0001750 00000065076 13613525371 011240 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
#include
#include
/*
* Module FBBdos
*/
static int execute_dos(void);
static int rx_file(char *, int);
static void copy_file(void);
static void dos_copy(void);
static void edit_label(void);
static void help_appel(char **);
static void menu_dos(void);
static void put_file(void);
static void view(void);
static int where_loop;
/*
* F_FILTER feature
*
* Parameters :
* Callsign-SSID
* Temp filename
* Number of the calling process (Xmodem=11, YAPP=17)
* Number of the user's record in INF.SYS
*
* Return value
* 0 : File OK, can be recorded.
* 1 : File not OK, will be discarded.
*
* Comments
* The datas sent to stdout by F_FILTER
* will be redirected to the user.
*/
/* return the next argument from indd and updates the indd pointer */
char *get_nextparam(void)
{
char *ptr;
while (*indd && isspace(*indd))
++indd;
if (*indd == '"')
{
ptr = ++indd;
while (*indd && (*indd != '"'))
++indd;
if (*indd)
*indd++ = '\0';
}
else
{
ptr = indd;
while (*indd && isgraph(*indd))
++indd;
if (*indd)
*indd++ = '\0';
}
return (*ptr) ? ptr : NULL;
}
int test_temp(int voie)
{
static int test = 1;
int retour = 1;
int ret;
char temp[128];
char s[256];
temp_name(voie, temp);
indd[80] = '\0';
if (test)
{
char dir[80];
char file[80];
FILE *fptr;
#ifdef __linux__
strcpy(dir, "X:/"); /* fill string with form of response: X:/ */
#else
strcpy(dir, "X:\\"); /* fill string with form of response: X:\ */
#endif
dir[0] = 'A' + getdisk(); /* replace X with current drive letter */
getcurdir(0, dir + 3); /* fill rest of string with current directory */
#ifdef __linux__
sprintf(file, "%s/f_filter.%02d", dir, voiecur);
#else
sprintf(file, "%s\\f_filter.%02d", dir, voiecur);
#endif
#ifdef __linux__
strcpy(file, back2slash(file));
#endif
if ((fptr = fopen(file, "wt")) == NULL)
return (-1);
fprintf(fptr, "#\n# Downloaded File information\n#\n");
#ifdef __linux__
fprintf(fptr, "TempName = %s\n", back2slash(temp));
fprintf(fptr, "FileName = %s\n", back2slash(pvoie->sr_fic));
#else
fprintf(fptr, "TempName = %s\n", temp);
fprintf(fptr, "FileName = %s\n", pvoie->sr_fic);
#endif
fprintf(fptr, "Label = %s\n", pvoie->label);
fprintf(fptr, "#\n");
fclose(fptr);
{
char buffer[1024];
*buffer = '\0';
#ifdef __linux__
/* sprintf(s, "%sf_filter %s-%d %d %u %s",
FILTDIR,*/
sprintf(s, "./f_filter %s-%d %d %u %s",
pvoie->sta.indicatif.call, pvoie->sta.indicatif.num,
pvoie->niv1, pvoie->ncur->coord, file);
ret = filter(s, buffer, sizeof(buffer), NULL, FILTDIR);
#else
sprintf(s, "f_filter %s-%d %d %u %s",
pvoie->sta.indicatif.call, pvoie->sta.indicatif.num,
pvoie->niv1, pvoie->ncur->coord, file);
ret = filter(s, buffer, sizeof(buffer), NULL, NULL);
#endif
buffer[1023] = '\0';
if (*buffer)
out(buffer, strlen(buffer));
}
unlink(file);
switch (ret)
{
case -1:
test = 0;
clear_outbuf(voiecur);
break;
case 1:
retour = 0;
break;
default:
break;
}
}
return (retour);
}
int user_ok(void)
{
if (droits(MODLABEL | SUPFIC | ACCESDOS))
return (1);
if (*pvoie->finf.priv)
return (1);
if (P_MODM(voiecur))
{
if (max_mod == 0)
return (1);
if (pvoie->finf.download > max_mod)
return (0);
}
else
{
if (max_yapp == 0)
{
return (1);
}
if (pvoie->finf.download > max_yapp)
{
return (0);
}
}
return (1);
}
void retour_dos(void)
{
retour_niveau();
prompt(pvoie->finf.flags, pvoie->niv1);
}
char *local_path(char *chaine)
{
int size, lg;
static char temp[256];
strcpy(temp, chaine);
size = lg = strlen(temp);
if ((lg > 2) && (temp[1] == ':'))
size = lg - 2;
if (size > 1)
if (temp[lg - 1] == '\\')
temp[lg - 1] = '\0';
return (temp);
}
int tst_point(char *chaine)
{
char *ptr;
char vdisk;
if ((voiecur != CONSOLE) &&
(pvoie->kiss != -2) && ((ptr = strchr(chaine, ':')) != NULL))
{
--ptr;
vdisk = toupper(*ptr) - 'A';
if (vdisk == 15)
{
if (*pvoie->finf.priv == '\0')
{
texte(T_ERR + 29);
return (FALSE);
}
}
else if ((vdisk > 7) || (PATH[(int) vdisk][0] == '\0'))
{
texte(T_ERR + 29);
return (FALSE);
}
}
if (!droits(ACCESDOS))
{
if (strstr(chaine, "..") || strstr(chaine, "~"))
{
texte(T_ERR + 15);
return (FALSE);
}
}
return (TRUE);
}
#if 0
/*
* Attend une structure tm en entree
* Retourne le nombre de secondes depuis 1-1-1970
*/
static long date_to_second(struct tm *dat)
{
static char Days[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
long x;
register int i;
register int days;
int hours;
x = 24L * 60L * 60L * 3652L + timezone; /* Convertit de 1980 a 1970 */
i = dat->tm_year;
if (i > 1900)
i -= 1900;
x += (i >> 2) * (1461L * 24L * 60L * 60L);
x += (i & 3) * (24L * 60L * 60L * 365L);
if (i & 3)
x += 24L * 3600L;
days = 0;
i = dat->tm_mon - 1;
while (i > 0)
{
i--;
days += Days[i];
}
days += dat->tm_mday - 1;
if (dat->tm_mon > 2 && (dat->tm_year & 3) == 0)
days++; /* bissextile */
hours = days * 24 + dat->tm_hour; /* Heures */
x += hours * 3600L;
x += 60L * dat->tm_min + dat->tm_sec;
return (x);
}
#endif
void send_file(int type)
{
int fin, retour;
char *ptr;
struct stat bufstat;
switch (pvoie->niv3)
{
case 0:
if (!user_ok())
{
texte(T_ERR + 18);
retour_dos();
break;
}
fin = 0;
if (type)
pvoie->lignes = -1;
get_nextparam();
if ((ptr = get_nextparam()) == NULL)
fin = T_ERR + 20;
else if (tst_point(ptr))
{
strcpy(pvoie->sr_fic, tot_path(ch_slash(ptr), pvoie->dos_path));
retour = stat(pvoie->sr_fic, &bufstat);
strcpy(pvoie->appendf, ptr);
if ((retour == -1) || ((bufstat.st_mode & S_IFREG) == 0))
{
fin = T_ERR + 11;
}
else
{
pvoie->enrcur = 0L;
pvoie->size_trans = 0L;
pvoie->temp2 = type;
if (senddata(0))
{
fin = -1;
pvoie->finf.download += (int) (pvoie->size_trans / 1024L);
}
else
ch_niv3(1);
}
}
if (fin)
{
if (type)
ctrl_z();
if (fin > 0)
texte(fin);
retour_dos();
}
break;
case 1:
if (senddata(0))
{
if (pvoie->temp2)
ctrl_z();
pvoie->finf.download += (int) (pvoie->size_trans / 1024L);
retour_dos();
}
break;
}
}
void put_file(void)
{
FILE *fptr;
obuf *msgtemp;
char temp[128];
if ((fptr = fopen(temp_name(voiecur, temp), "at")) != NULL)
{
while ((msgtemp = pvoie->msgtete) != NULL)
{
fwrite(msgtemp->buffer, msgtemp->nb_car, 1, fptr);
pvoie->memoc -= msgtemp->nb_car;
pvoie->msgtete = msgtemp->suiv;
m_libere((char *) msgtemp, sizeof(*msgtemp));
}
fclose(fptr);
}
libere(voiecur);
}
static int rx_file(char *ptr, int nbcar)
{
int ncars;
obuf *msgtemp;
char *ptcur;
if ((msgtemp = pvoie->msgtete) != NULL)
{
while (msgtemp->suiv)
msgtemp = msgtemp->suiv;
}
else
{
msgtemp = (obuf *) m_alloue(sizeof(obuf));
pvoie->msgtete = msgtemp;
msgtemp->nb_car = msgtemp->no_car = 0;
msgtemp->suiv = NULL;
}
ncars = msgtemp->nb_car;
ptcur = msgtemp->buffer + ncars;
while (nbcar--)
{
if (*ptr == '\32')
{
msgtemp->nb_car = ncars;
put_file();
ltoa(pvoie->tailm, varx[0], 10);
texte(T_DOS + 5);
return (FALSE);
}
++pvoie->tailm;
if (*ptr == '\r')
{
++pvoie->tailm;
*ptr = '\n';
}
++pvoie->memoc;
*ptcur++ = *ptr++;
if (++ncars == 250)
{
msgtemp->nb_car = ncars;
msgtemp->suiv = (obuf *) m_alloue(sizeof(obuf));
msgtemp = msgtemp->suiv;
msgtemp->nb_car = msgtemp->no_car = ncars = 0;
msgtemp->suiv = NULL;
ptcur = msgtemp->buffer;
}
}
msgtemp->nb_car = ncars;
if (pvoie->memoc > MAXMEM)
put_file();
return (TRUE);
}
void receive_file(void)
{
char *ptr;
struct stat bufstat;
switch (pvoie->niv3)
{
case 0:
if (read_only())
{
retour_dos();
break;
}
get_nextparam();
if ((ptr = get_nextparam()) == NULL)
{
texte(T_ERR + 20);
retour_dos();
break;
}
if ((!tst_point(ptr)) || (!aut_ecr(ch_slash(ptr), 1)))
{
retour_dos();
break;
}
entete_saisie();
pvoie->tailm = 0L;
n_cpy(40, pvoie->appendf, ptr);
strcpy(pvoie->sr_fic,
tot_path(ch_slash(pvoie->appendf), pvoie->dos_path));
if (stat(pvoie->sr_fic, &bufstat) == -1)
{
del_temp(voiecur);
/* unlink(pvoie->sr_fic) ; */
pvoie->xferok = 0;
texte(T_YAP + 3);
maj_niv(9, 3, 2);
}
else
{
texte(T_ERR + 23);
retour_dos();
}
break;
case 1:
if (rx_file(indd, nb_trait) == 0)
{
pvoie->xferok = 1;
if (test_temp(voiecur))
{
rename_temp(voiecur, pvoie->sr_fic);
wr_dir(pvoie->sr_fic, pvoie->sta.indicatif.call);
}
retour_dos();
}
break;
case 2:
new_label();
texte(T_DOS + 6);
maj_niv(9, 3, 1);
break;
}
}
void dos_copy(void)
{
struct stat bufstat;
int fd_orig, fd_dest;
long nb_oct;
Rlabel rlabel;
FILE *fptr;
char *ptri, *ptro, *ptr;
char orig[80];
int r;
get_nextparam();
if ((ptri = get_nextparam()) == NULL)
{
texte(T_ERR + 20);
return;
}
if ((ptro = get_nextparam()) == NULL)
{
texte(T_ERR + 21);
return;
}
if (strcmpi(ptri, ptro) == 0)
{
texte(T_ERR + 23);
return;
}
if (!tst_point(ptri))
return;
if (!tst_point(ptro))
return;
strcpy(orig, tot_path(ch_slash(ptri), pvoie->dos_path));
stat(orig, &bufstat);
strcpy(pvoie->appendf, ptri);
if ((bufstat.st_mode & S_IFREG) == 0)
{
texte(T_ERR + 11);
return;
}
if ((fd_orig = open(orig, O_RDONLY | O_BINARY)) == EOF)
{
texte(T_ERR + 11);
return;
}
if (!aut_ecr(ch_slash(ptro), 1))
{
close(fd_orig);
return;
}
strcpy(pvoie->appendf, ptro);
strcpy(pvoie->sr_fic, tot_path(ch_slash(ptro), pvoie->dos_path));
r = stat(pvoie->sr_fic, &bufstat);
if ((r == 0 && (bufstat.st_mode & S_IFREG) == 0) || errno != ENOENT)
{
texte(T_ERR + 11);
return;
}
if ((fd_dest =
open(pvoie->sr_fic, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
S_IREAD | S_IWRITE)) == EOF)
{
texte(T_ERR + 30);
close(fd_orig);
return;
}
nb_oct = copy_fic(fd_orig, fd_dest, NULL);
close(fd_orig);
close(fd_dest);
wr_dir(pvoie->sr_fic, pvoie->sta.indicatif.call);
*rlabel.label = '\0';
ptr = vir_path(orig);
fptr = NULL;
if ((ptr) && ((fptr = fopen(d_disque("YAPPLBL.DAT"), "rb")) != NULL))
{
while (fread(&rlabel, sizeof(Rlabel), 1, fptr))
{
if (strcmp(ptr, rlabel.nomfic) == 0)
{
fclose(fptr);
fptr = NULL;
w_label(pvoie->sr_fic, rlabel.label);
break;
}
}
}
if (fptr)
fclose(fptr);
ltoa(nb_oct, varx[0], 10);
texte(T_DOS + 7);
return;
}
void copy_file(void)
{
if (!read_only())
dos_copy();
prompt_dos();
}
void del_file(void)
{
char *ptr;
if (!read_only())
{
get_nextparam();
if ((ptr = get_nextparam()) == NULL)
{
texte(T_ERR + 20);
}
else
{
if (tst_point(ptr))
{
if (aut_ecr(ch_slash(ptr), 1))
{
strcpy(pvoie->appendf, ptr);
if (unlink(tot_path(ptr, pvoie->dos_path)) == 0)
texte(T_DOS + 10);
else
texte(T_ERR + 11);
}
}
}
}
retour_dos();
}
static void edit_label(void)
{
char *ptr;
switch (pvoie->niv3)
{
case 0:
if (droits(MODLABEL))
{
struct stat st;
get_nextparam();
if ((ptr = get_nextparam()) == NULL)
{
texte(T_ERR + 20);
retour_dos();
break;
}
if (!tst_point(ptr) || !aut_ecr(ptr, 0))
{
retour_dos();
break;
}
n_cpy(40, pvoie->appendf, ptr);
strcpy(pvoie->sr_fic,
tot_path(ch_slash(pvoie->appendf), pvoie->dos_path));
if (stat(pvoie->sr_fic, &st) == -1)
{
texte(T_ERR + 11);
retour_dos();
break;
}
texte(T_YAP + 3);
ch_niv3(1);
}
else
{
texte(T_ERR + 1);
retour_dos();
}
break;
case 1:
while ((*indd) && (!ISPRINT(*indd)))
++indd;
if (ISGRAPH(*indd))
{
w_label(pvoie->sr_fic, sup_ln(indd));
cr();
dir_yapp(pvoie->appendf);
}
retour_dos();
break;
}
}
void help_appel(char *appel[])
{
char s[80];
int i = 0;
texte(T_DOS + 8);
texte(T_DOS + 9);
while (1)
{
if (*appel[i] == '\0')
break;
sprintf(s, "%-10s", appel[i]);
outs(s, strlen(s));
if ((++i % 6) == 0)
outs("\n", 1);
}
outs("\n\n", 2);
}
#ifdef __WINDOWS__
static int execute_dos(void)
{
char buf[80];
char cmd[256];
int disk;
int i;
int ret;
char cur_dir[MAXPATH];
char fbbdos_dir[MAXPATH];
while (isalnum(*indd))
++indd;
while_space();
if (*indd)
{
/* recupere disque et repertoire courants */
disk = getdisk();
strcpy(cur_dir, "X:\\");
cur_dir[0] = 'A' + disk;
getcurdir(0, cur_dir + 3);
strcpy(fbbdos_dir, tot_path("", pvoie->dos_path));
if ((i = strlen(fbbdos_dir)) > 3)
fbbdos_dir[i - 1] = '\0';
operationnel = 2;
{
char deroute[80];
wsprintf(deroute, "%sexecute.$$$", MBINDIR);
ret =
call_nbdos(&indd, 1, REPORT_MODE, deroute, fbbdos_dir, NULL);
if (ret != -1)
outfichs(deroute);
unlink(deroute);
}
operationnel = 1;
if (ret == -1)
texte(T_ERR + 8);
else if (ret != 0)
{
texte(T_ERR + 8);
wsprintf(buf, "Errorlevel = %d", ret);
outln(buf, strlen(buf));
}
}
else
{
texte(T_ERR + 20);
}
prompt_dos();
return (1);
}
#endif
#ifdef __linux__
static int execute_dos(void)
{
char buf[256];
int ret;
/* run a task under linux. This task is blocking ... */
/* Skip DOS command */
while (isalnum(*indd))
++indd;
while_space();
operationnel = 2;
{
char deroute[80];
char fbbdos_dir[256];
char *ptr;
int i;
strcpy(fbbdos_dir, tot_path("", pvoie->dos_path));
if ((i = strlen(fbbdos_dir)) > 3)
fbbdos_dir[i - 1] = '\0';
sprintf(deroute, "%sexecute.xxx", MBINDIR);
ptr = indd;
/* Look for a semi-column or pipe command */
while (*ptr)
{
if (*ptr == ';' || *ptr == '|')
{
*ptr = '\0';
break;
}
ptr++;
}
ret = call_nbdos(&indd, 1, REPORT_MODE, deroute, fbbdos_dir, NULL);
if (ret != -1)
outfichs(deroute);
unlink(deroute);
}
operationnel = 1;
if (ret == -1)
texte(T_ERR + 8);
else if (ret != 0)
{
texte(T_ERR + 8);
sprintf(buf, "Errorlevel = %d", ret);
outln(buf, strlen(buf));
}
prompt_dos();
return (1);
}
#endif
#ifdef __FBBDOS__
static int execute_dos(void)
{
int retour = 1;
static char slash_c[] = "/C";
char *arg[20];
char *ptr;
char log[80];
int i = 0;
int disk;
int ofst;
int duplic, oldstdout, oldstderr;
char deroute[80];
char cur_dir[MAXPATH];
char fbbdos_dir[MAXPATH];
sprintf(deroute, "%s\\EXECUTE.$$$", getcwd(log, 80));
strtok(indd, " ");
arg[i++] = getenv("COMSPEC");
arg[i++] = slash_c;
while ((arg[i] = strtok(NULL, " ")) != NULL)
++i;
if (i == 2)
{
retour = -1;
texte(T_ERR + 20);
}
else
{
ofst = 2;
ptr = strrchr(arg[2], '.');
if (ptr)
{
if (strcmp(strupr(ptr + 1), "BAT") == 0)
ofst = 0;
}
deb_io();
/* redirige stdout et stderr sur le fichier EXECUTE.$$$ */
duplic = open(deroute, O_CREAT | O_RDWR, S_IWRITE | S_IREAD);
oldstdout = dup(1);
oldstderr = dup(2);
dup2(duplic, 1);
dup2(duplic, 2);
close(duplic);
/* recupere disque et repertoire courants */
disk = getdisk();
strcpy(cur_dir, "X:\\");
cur_dir[0] = 'A' + disk;
getcurdir(0, cur_dir + 3);
strcpy(fbbdos_dir, tot_path("", pvoie->dos_path));
setdisk(fbbdos_dir[0] - 'A');
if ((i = strlen(fbbdos_dir)) > 3)
fbbdos_dir[i - 1] = '\0';
chdir(fbbdos_dir);
operationnel = 2;
break_ok();
retour = spawnvp(P_WAIT, arg[ofst], arg + ofst);
if (retour == -1)
{
ofst = 0;
retour = spawnvp(P_WAIT, arg[ofst], arg + ofst);
}
break_stop();
operationnel = 1;
/* remet disque et repertoire courants */
setdisk(disk);
chdir(cur_dir);
/* Supprime les redirections */
dup2(oldstdout, 1);
dup2(oldstderr, 2);
close(oldstdout);
close(oldstderr);
fin_io();
outfich(deroute);
unlink(deroute);
if (retour == -1)
texte(T_ERR + 8);
else if (retour != 0)
{
texte(T_ERR + 8);
sprintf(log, "Errorlevel = %d", retour);
outln(log, strlen(log));
}
}
prompt_dos();
return (retour);
}
#endif
static void view(void)
{
char *ptr;
char temp[256];
get_nextparam();
ptr = get_nextparam();
if ((ptr) && (strchr(ptr, '/') == NULL))
{
#ifdef __linux__
{
static char *fbb_view = "fbb_view";
char *vptr = getenv("FBB_VIEW");
if (vptr == NULL)
vptr = fbb_view;
sprintf(temp, "DOS %s %s", vptr, back2slash(ptr));
}
#else
sprintf(temp, "DOS FV %s", ptr);
#endif
indd = temp;
maj_niv(9, 99, 0);
execute_dos();
cr();
}
else
{
texte(T_ERR + 20);
prompt_dos();
}
}
static int where(int lg, char *path, char *pattern)
{
struct ffblk ffblk;
char rech[80];
char temp[128];
int done = 1;
int premier = 1;
int retour = 0;
strcpy(rech, path);
#ifdef __linux__
strcat(rech, "*");
#else
strcat(rech, "*.*");
#endif
++where_loop;
done = findfirst(rech, &ffblk, FA_DIREC);
while (!done)
{
if (*ffblk.ff_name != '.')
{
if (ffblk.ff_attrib & FA_DIREC)
{
strcpy(temp, path);
strcat(temp, ffblk.ff_name);
strcat(temp, "\\");
if ((strncmp(temp + 1, ":\\PROC\\", 7) != 0)
&& (where_loop < 16))
{
if (where(lg, temp, pattern))
retour = 1;
}
premier = 1;
}
else
{
if (strmatch(ffblk.ff_name, pattern))
{
if (premier)
{
char v;
if (pvoie->vdisk == 8)
v = 'P';
else
v = 'A' + pvoie->vdisk;
sprintf(temp, "%c:%s :", v, path + lg);
outln(temp, strlen(temp));
premier = 0;
}
*varx[4] = *varx[5] = *varx[6] = *varx[7] = '\0';
sprintf(varx[0], " %-13s", ffblk.ff_name);
var_cpy(2, dir_date(ffblk.ff_fdate));
*varx[3] = '\0';
if ((ffblk.ff_attrib & FA_DIREC) != 0)
{
var_cpy(1, " ");
}
else
{
sprintf(varx[1], "%6ld", ffblk.ff_fsize);
}
texte(T_DOS + 3);
retour = 1;
if (pvoie->memoc >= MAXMEM)
break;
}
}
}
done = findnext(&ffblk);
}
--where_loop;
return (retour);
}
static void where_file(void)
{
int lg;
int retour = 0;
char *ptr;
get_nextparam();
pvoie->noenr_menu = 0L;
ptr = get_nextparam();
if (ptr == NULL)
{
texte(T_ERR + 20);
retour_dos();
return;
}
if (tst_point(ptr))
{
char cur_dir[80];
int sav_vdisk = pvoie->vdisk;
for (pvoie->vdisk = 0; pvoie->vdisk < 9; ++pvoie->vdisk)
{
if (*PATH[(int)pvoie->vdisk] == '\0')
continue;
if ((pvoie->vdisk == 8) && (*pvoie->finf.priv == '\0'))
continue;
/* strcpy (cur_dir, tot_path ("\0", "\\")); */
strcpy(cur_dir, PATH[(int)pvoie->vdisk]);
lg = strlen(cur_dir);
where_loop = 0;
if (where(lg - 1, cur_dir, ptr))
retour = 1;
}
pvoie->vdisk = sav_vdisk;
}
if (pvoie->memoc >= MAXMEM)
outln("....", 4);
else if (!retour)
texte(T_DOS + 2);
retour_dos();
}
void menu_dos(void)
{
int i, error = 0;
int vdisk;
char *iptr, *optr, commande[80];
static char *appel[] = {
"HELP", "?", "O",
"DIR", "EDIT", "GET", "PUT", "CD", "MD", "MKDIR",
"COPY", "DEL", "RD", "RMDIR", "TYPE", "DU", "YGET", "YPUT",
"XGET", "XPUT", "LIST", "VIEW", "NEW", "LABEL", "WHERE",
"X1GET", "ZGET", "ZPUT", "BGET", "BPUT",
"EXIT", "QUIT", "F", "B", "\0"
};
char com[80];
char temp[80];
limite_commande();
while (*indd && (!ISGRAPH(*indd)))
indd++;
strn_cpy(70, com, indd);
sup_ln(indd);
if (*indd == '\0')
{
prompt_dos();
return;
}
if (strncmp(com, "PRIV", 4) == 0)
{
fbb_log(voiecur, 'D', com);
if (*pvoie->finf.priv)
{
pvoie->vdisk = 8;
strcpy(pvoie->dos_path, "\\");
}
else
texte(T_ERR + 29);
prompt_dos();
return;
}
if ((droits(EXEDOS)) && (strncmp(com, "DOS", 3) == 0))
{
fbb_log(voiecur, 'D', com);
maj_niv(9, 99, 0);
execute_dos();
return;
}
if ((com[1] == ':') && (!ISGRAPH(com[2])))
{
#ifdef __linux__
if (voiecur == CONSOLE)
{
static char *txt = "Cannot select a virtual disk in console mode";
outln(txt, strlen(txt));
prompt_dos();
return;
}
#endif
vdisk = toupper(com[0]) - 'A';
if (vdisk == 15)
{
vdisk = 8;
}
strcat(com, "\\");
if ((voiecur == CONSOLE) && (is_dir(com)))
{
pvoie->vdisk = vdisk;
strcpy(pvoie->dos_path, "\\");
}
else if ((voiecur != CONSOLE) && (vdisk < 8) && (*PATH[vdisk]))
{
pvoie->vdisk = vdisk;
strcpy(pvoie->dos_path, "\\");
}
else if ((vdisk == 8) && (*pvoie->finf.priv))
{
pvoie->vdisk = vdisk;
strcpy(pvoie->dos_path, "\\");
}
else
texte(T_ERR + 29);
prompt_dos();
return;
}
if ((strncmp(com, "HELP", 4) == 0) || (*com == '?') || (*com == 'H'))
{
if (*com == '?')
++indd;
else
{
while (ISGRAPH(*indd))
++indd;
}
while_space();
if (*indd == '\0')
*--indd = '?';
if (!out_help(indd))
help_appel(appel);
*indd = '\0';
}
if ((strncmp(com, "CD", 2) == 0) && (ISGRAPH(*(com + 2))))
{
sprintf(temp, "CD %s", com + 2);
indd = temp;
}
if (*indd)
{
iptr = indd;
optr = commande;
while (ISGRAPH(*iptr))
{
*optr = (islower(*iptr)) ? toupper(*iptr) : *iptr;
iptr++;
optr++;
}
*optr = '\0';
if (*commande == 'O')
commande[1] = '\0';
i = 0;
while (1)
{
optr = commande;
var_cpy(0, optr);
if (*appel[i] == '\0')
{
texte(T_ERR + 1);
prompt_dos();
return;
}
if (strncmp(appel[i], optr, 3) == 0)
break;
++i;
}
pvoie->temp1 = N_DOS;
switch (i)
{
case 0:
case 1: /* help_appel(appel) ; */
break;
case 2:
indd = com + 1;
mbl_options();
retour_dos();
break;
case 3:
maj_niv(9, 1, 0);
dir();
break;
case 4:
maj_niv(9, 9, 0);
edit();
break;
case 5:
maj_niv(9, 2, 0);
send_file(1);
break;
case 6:
if (!is_room())
{
outln("*** Disk full !", 15);
error = 4;
break;
}
maj_niv(9, 3, 0);
receive_file();
break;
case 7:
maj_niv(9, 4, 0);
change_dir();
break;
case 8:
case 9:
maj_niv(9, 5, 0);
make_dir();
break;
case 10:
if (!is_room())
{
outln("*** Disk full !", 15);
error = 4;
break;
}
maj_niv(9, 6, 0);
copy_file();
break;
case 11:
maj_niv(9, 7, 0);
del_file();
break;
case 12:
case 13:
maj_niv(9, 8, 0);
remove_dir();
break;
case 14:
maj_niv(9, 2, 0);
send_file(0);
break;
case 15:
du();
break;
case 16:
if (!user_ok())
{
error = 3;
}
else
{
if (P_MODM(voiecur))
{
var_cpy(0, "YMODEM");
maj_niv(N_MOD, 4, XS_INIT);
pvoie->type_yapp = 2;
xmodem();
}
else
{
indd += 3;
*indd = 'D';
maj_niv(N_YAPP, 0, 0);
menu_yapp();
}
}
break;
case 17:
if (!is_room())
{
outln("*** Disk full !", 15);
error = 4;
break;
}
if (P_MODM(voiecur))
{
#if defined(__WINDOWS__) || defined(__linux__)
var_cpy(0, "YMODEM");
maj_niv(N_MOD, 4, XR_INIT);
pvoie->type_yapp = 2;
xmodem();
#else
var_cpy(0, "YMODEM");
pvoie->type_yapp = 2;
error = 2;
#endif
}
else
{
indd += 3;
*indd = 'U';
maj_niv(N_YAPP, 0, 0);
menu_yapp();
}
break;
case 18:
var_cpy(0, "XMODEM");
if (P_MODM(voiecur))
{
if (!user_ok())
error = 3;
else
{
maj_niv(N_MOD, 4, XS_INIT);
pvoie->type_yapp = 0;
xmodem();
}
}
else
error = 2;
break;
case 19:
if (!is_room())
{
outln("*** Disk full !", 15);
error = 4;
break;
}
var_cpy(0, "XMODEM");
if (P_MODM(voiecur))
{
maj_niv(N_MOD, 4, XR_INIT);
pvoie->type_yapp = 0;
xmodem();
}
else
error = 2;
break;
case 20:
maj_niv(9, 10, 0);
list();
break;
case 21:
maj_niv(9, 11, 0);
view();
break;
case 22:
maj_niv(9, 12, 0);
dir_new();
break;
case 23:
maj_niv(9, 14, 0);
edit_label();
break;
case 24:
maj_niv(9, 16, 0);
where_file();
break;
case 25:
var_cpy(0, "1K-XMODEM");
if (P_MODM(voiecur))
{
if (!user_ok())
error = 3;
else
{
maj_niv(N_MOD, 4, XS_INIT);
pvoie->type_yapp = 1;
xmodem();
}
}
else
error = 2;
break;
case 26:
var_cpy(0, "ZMODEM");
if (P_MODM(voiecur))
{
if (!user_ok())
error = 3;
else
{
maj_niv(N_MOD, 4, XS_INIT);
pvoie->type_yapp = 3;
xmodem();
}
}
else
error = 2;
break;
case 27:
if (!is_room())
{
outln("*** Disk full !", 15);
error = 4;
break;
}
var_cpy(0, "ZMODEM");
if ((P_MODM(voiecur))
&& ((BIOS(no_port(voiecur)) == P_WINDOWS)
|| (BIOS(no_port(voiecur)) == P_LINUX)))
{
if (!user_ok())
error = 3;
else
{
maj_niv(N_MOD, 4, XR_INIT);
pvoie->type_yapp = 3;
xmodem();
}
}
else
error = 2;
break;
case 28:
if (!user_ok())
{
error = 3;
}
else
{
maj_niv(N_BIN, 0, 0);
bin_transfer();
}
break;
case 29:
if (!is_room())
{
outln("*** Disk full !", 15);
error = 4;
break;
}
maj_niv(N_BIN, 0, 4);
bin_transfer();
break;
case 30:
case 31:
case 32:
error = 1;
retour_mbl();
break;
case 33:
indd = com + 1;
if (bye())
{
error = 1;
maj_niv(N_MENU, 0, 0);
sortie();
}
break;
default:
error = 1;
retour_mbl();
break;
}
switch (error)
{
case 2:
texte(T_YAP + 2);
prompt_dos();
break;
case 3:
texte(T_ERR + 18);
prompt_dos();
break;
case 4:
prompt_dos();
break;
case 0:
fbb_log(voiecur, 'D', com);
break;
}
}
else
prompt_dos();
}
void dos(void)
{
switch (pvoie->niv2)
{
case 0:
menu_dos();
break;
case 1:
dir();
break;
case 2:
send_file(0);
break;
case 3:
receive_file();
break;
case 4:
change_dir();
break;
case 5:
make_dir();
break;
case 6:
copy_file();
break;
case 7:
del_file();
break;
case 8:
remove_dir();
break;
case 9:
edit();
break;
case 10:
list();
break;
case 11:
view();
break;
case 12:
dir_new();
break;
case 14:
edit_label();
break;
case 15:
bin_transfer();
break;
case 16:
where_file();
break;
case 99:
execute_dos();
break;
default:
fbb_error(ERR_NIVEAU, "FBBDOS", pvoie->niv2);
break;
}
}
fbb-7.0.11/src/drv_sock.c 0000664 0001750 0001750 00000110741 13771425764 012045 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
/******************************************************
* *
* FBB Driver for AF_AX25 domain sockets *
* *
* F6FBB - 1996 *
* *
******************************************************/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
union sockaddr_ham
{
struct full_sockaddr_ax25 axaddr;
struct sockaddr_rose rsaddr;
};
#define AX25_CALLSID 11 /* Big enough for ROSE addresses */
#define READ_EVENT 1
#define WRITE_EVENT 2
#define EXCEPT_EVENT 4
#define DISCONNECT 0
#define CPROGRESS 1
#define CONNECTED 2
#define NO_EVENT 0
#define DISC_EVENT 1
#define CONN_EVENT 2
#define RETR_EVENT 3
#define BUSY_EVENT 4
#define SOCK_MAXCAN (MAXVOIES) /* was 50 -- this was causing bad problems.
This table was being accessed beyond the array */
#define CAN_AX25 0
#define CAN_NETROM 1
#define CAN_ROSE 2
#ifndef SOL_AX25
#define SOL_AX25 257
#endif
#undef open
#undef read
#undef write
#undef close
typedef struct
{
int ncan;
int sock;
int port;
int state;
int paclen;
int maxframe;
int type; /* CAN_AX25, CAN_NETROM or CAN_ROSE */
int event;
int queue;
char source[AX25_CALLSID];
}
scan_t;
scan_t scan[SOCK_MAXCAN] = {{0}}; /* I think this is necessary (Though not 100% sure. */
static int last_can = 1;
static int msocket = -1;
static int is_rsaddr (char *);
static int stop_cnx (int port);
static int sock_rcv_ui (int *, char *, int *, ui_header *);
static int sock_snd_ui (int, char *, int, Beacon *);
static int sock_snd_dt (int, char *, int);
static int sock_cmd (int, int, char *);
static int sock_connect (char *, int);
static int sock_connexion (int, int, union sockaddr_ham *, int *, char *);
static int sock_stat (int, stat_ch *);
static int sock_paclen (int);
static int s_free (scan_t *);
static int s_status (scan_t *);
static int name_to_port (char *);
static char *ax25_ntoaddr (char *, const ax25_address *);
static char *rose_ntoaddr (char *, const rose_address *);
static char *rose_ntodnic (char *, const rose_address *);
static void clear_can (int canal);
/*
* ax25 -> ascii conversion
*/
static char *_ax25_ntoa(const ax25_address *a)
{
static char buf[11];
char c, *s;
int n;
for (n = 0, s = buf; n < 6; n++) {
c = (a->ax25_call[n] >> 1) & 0x7F;
if (c != ' ')
*s++ = c;
}
*s++ = '-';
n = (a->ax25_call[6] >> 1) & 0x0F;
if (n > 9) {
*s++ = '1';
n -= 10;
}
*s++ = n + '0';
*s++ = '\0';
return buf;
}
/*
* Generic functions of the driver
*/
/* Check or change status of a port/channel */
int sta_sck (int port, int canal, int cmd, void *ptr)
{
switch (cmd)
{
case TNCSTAT:
return (sock_stat (canal, (stat_ch *) ptr));
case PACLEN:
*((int *) ptr) = sock_paclen (canal);
return (1);
case SNDCMD:
return (sock_cmd (port, canal, (char *) ptr));
case SETBUSY:
return stop_cnx (port);
}
return (0);
}
/* Sends data */
int snd_sck (int port, int canal, int cmd, char *buffer, int len, Beacon * ptr)
{
int ret = 0;
switch (cmd)
{
case COMMAND:
break;
case DATA:
if (len != 0)
ret = sock_snd_dt (canal, buffer, len);
//else
//fprintf (stderr, "FBB snd_sck() DATA len == 0 !\n");
break;
case UNPROTO:
ret = sock_snd_ui (port, buffer, len, ptr);
break;
}
return (ret);
}
/* receives data */
int rcv_sck (int *port, int *canal, int *cmd, char *buffer, int *len, ui_header * ui)
{
static int can = 0;
/* int valid;*/
int res;
*cmd = INVCMD;
/* valid = 0;*/
/* Test monitoring */
if (sock_rcv_ui (port, buffer, len, ui))
{
*canal = 0;
*cmd = UNPROTO;
return (1);
}
usleep(50000); /* wait 50 msec to allow interrupt and avoid CPU overload */
/* Test connection */
scan[0].sock = p_port[*port].fd;
res = s_status (&scan[0]);
if (res & READ_EVENT)
{
int new;
int i;
unsigned addr_len;
union sockaddr_ham addr;
memset(&addr, 0x00, sizeof(struct full_sockaddr_ax25));
/* addr_len = sizeof (union sockaddr_ham);*/
addr_len = sizeof (struct full_sockaddr_ax25);
new = accept (p_port[*port].fd, (struct sockaddr *) &addr, &addr_len);
if (new == -1)
{
perror ("rcv_sck() accept");
return (FALSE);
}
/* Affect the new socket to an empty channel */
for (i = 1; i < last_can; i++)
{
if (scan[i].state == DISCONNECT)
{
break;
}
}
if (i == last_can)
{
/* Impossible to affect the channel -> disconnection */
printf ("no channel available\n");
close (new);
}
else
{
int ret;
*canal = i;
ret = sock_connexion (new, i, &addr, port, buffer);
if (ret)
{
*len = strlen (buffer);
*cmd = COMMAND;
*canal = i;
return (TRUE);
}
return (FALSE);
}
}
/* Next channel for the polling */
++can;
if (can == last_can)
can = 1;
if ((scan[can].sock <= 0) && (scan[can].state != DISCONNECT))
{
switch (scan[can].type)
{
case CAN_AX25:
sprintf (buffer, "(%d) DISCONNECTED fm AX25", can);
/* fprintf (stderr, "(%d) DISCONNECTED fm AX25\n", can);*/
break;
case CAN_NETROM:
sprintf (buffer, "(%d) DISCONNECTED fm NETROM", can);
/* fprintf (stderr, "(%d) DISCONNECTED fm NETROM\n", can);*/
break;
case CAN_ROSE:
sprintf (buffer, "(%d) DISCONNECTED fm ROSE", can);
/* fprintf (stderr, "(%d) DISCONNECTED fm ROSE\n", can);*/
break;
}
clear_can (can);
/* scan[can].state = DISCONNECT; */
*len = strlen (buffer);
*cmd = COMMAND;
*canal = can;
return (TRUE);
}
/* Canal de communication */
res = s_status (&scan[can]);
if (res & EXCEPT_EVENT)
{
if (scan[can].event == CONN_EVENT)
{
/* Appel sortant connecte */
unsigned addr_len;
union sockaddr_ham addr;
int ret;
memset(&addr, 0x00, sizeof(struct full_sockaddr_ax25));
/* addr_len = sizeof (union sockaddr_ham);*/
addr_len = sizeof (struct full_sockaddr_ax25);
if (getpeername (scan[can].sock, (struct sockaddr *) &addr, &addr_len) == 0)
{
ret = sock_connexion (scan[can].sock, can, &addr, port, buffer);
if (ret)
{
*len = strlen (buffer);
*cmd = COMMAND;
*canal = can;
return (TRUE);
}
}
else
/* perror ("getpeername");*/
return (FALSE);
}
else
{
switch (scan[can].type)
{
case CAN_AX25:
sprintf (buffer, "(%d) DISCONNECTED fm AX25", can);
/* fprintf (stderr, "(%d) DISCONNECTED fm AX25\n", can);*/
break;
case CAN_NETROM:
sprintf (buffer, "(%d) DISCONNECTED fm NETROM", can);
/* fprintf (stderr, "(%d) DISCONNECTED fm NETROM\n", can);*/
break;
case CAN_ROSE:
sprintf (buffer, "(%d) DISCONNECTED fm ROSE", can);
/* fprintf (stderr, "(%d) DISCONNECTED fm ROSE\n", can);*/
break;
}
/* printf ("Event -> deconnection %s\n", buffer);*/
close (scan[can].sock);
clear_can (can);
*len = strlen (buffer);
*cmd = COMMAND;
*canal = can;
return (TRUE);
}
}
if (res & READ_EVENT)
{
int nb;
if (scan[can].sock <= 0)
{
/* printf ("read on invalid socket\n");*/
return (FALSE);
}
nb = read (scan[can].sock, buffer, 256);
if ((nb == 0) || ((nb == -1) && (errno == ENOTCONN)))
{
/* Deconnection */
switch (scan[can].type)
{
case CAN_AX25:
sprintf (buffer, "(%d) DISCONNECTED fm AX25", can);
/* fprintf (stderr, "(%d) DISCONNECTED fm AX25\n", can);*/
break;
case CAN_NETROM:
sprintf (buffer, "(%d) DISCONNECTED fm NETROM", can);
/* fprintf (stderr, "(%d) DISCONNECTED fm NETROM\n", can);*/
break;
case CAN_ROSE:
sprintf (buffer, "(%d) DISCONNECTED fm ROSE", can);
/* fprintf (stderr, "(%d) DISCONNECTED fm ROSE\n", can);*/
break;
}
close (scan[can].sock);
clear_can (can);
*len = strlen (buffer);
*cmd = COMMAND;
*canal = can;
return (TRUE);
}
else if (nb == -1)
{
printf ("errno = %d\n", errno);
perror ("read");
}
else
{
*len = nb;
*cmd = DATA;
*canal = can;
return (TRUE);
}
}
if (res & WRITE_EVENT)
{
/* Can write to the socket... Unused */
}
return (FALSE);
}
/* Open port */
int opn_sck (int port, int nb)
{
static int nb_init = 0;
int old_can;
int i;
int ioc;
int backoff;
int ok = TRUE;
char s[80];
char *p_name;
sprintf (s, "Init PORT %d COM%d-%d",
port, p_port[port].ccom, p_port[port].ccanal);
InitText (s);
old_can = last_can;
last_can += nb;
if (last_can > SOCK_MAXCAN)
last_can = SOCK_MAXCAN;
for (i = old_can; i < last_can; i++)
{
clear_can (i);
}
if (nb_init == 0)
{
nb_init = 1;
fbb_ax25_config_load_ports ();
fbb_nr_config_load_ports ();
fbb_rs_config_load_ports ();
/* Socket reception monitoring */
if (msocket <= 0)
{
int proto = (all_packets) ? ETH_P_ALL : ETH_P_AX25;
if ((msocket = socket (AF_PACKET, SOCK_PACKET, htons (proto))) == -1)
{
perror ("socket_monitoring");
}
else
{
/* Socket non bloquant */
ioc = 1;
ioctl (msocket, FIONBIO, &ioc);
}
}
}
/* Receive connections socket */
if (p_port[port].fd == 0)
{
char call[20];
int addrlen = 0;
union sockaddr_ham addr;
memset(&addr, 0x00, sizeof(struct full_sockaddr_ax25));
sprintf (s, "Open PORT %d COM%d-%d",
port, p_port[port].ccom, p_port[port].ccanal);
/* fprintf (stderr, "Open PORT %d COM%d-%d\n",
port, p_port[port].ccom, p_port[port].ccanal);
*/ InitText (s);
sleep (1);
if (ax25_config_get_addr (p_port[port].name) != NULL)
{
p_port[port].type = CAN_AX25;
}
else if (nr_config_get_addr (p_port[port].name) != NULL)
{
p_port[port].type = CAN_NETROM;
}
else if (is_rsaddr (p_port[port].name) || (rs_config_get_addr (p_port[port].name) != NULL))
{
p_port[port].type = CAN_ROSE;
}
else
{
/* fprintf (stderr, "invalid port name %s\n", p_port[port].name);*/
return (0);
}
switch (p_port[port].type)
{
case CAN_AX25:
printf ("CAN_AX25\n");
if ((p_port[port].fd = socket (AF_AX25, SOCK_SEQPACKET, 0)) < 0)
{
perror ("socket_r");
clear_can (port);
return (0);
}
/* Socket non bloquant */
ioc = 1;
ioctl (p_port[port].fd, FIONBIO, &ioc);
backoff = 0;
if (setsockopt (p_port[port].fd, SOL_AX25, AX25_BACKOFF, &backoff, sizeof (backoff)) == -1)
{
perror ("setsockopt : AX25_BACKOFF");
close (p_port[port].fd);
clear_can (port);
return (0);
}
addr.axaddr.fsa_ax25.sax25_family = AF_AX25;
addr.axaddr.fsa_ax25.sax25_ndigis = 1;
sprintf (call, "%s-%d", mycall, myssid);
fprintf (stderr, "CAN_AX25 mycall %s myssid %d\n", mycall, myssid);
ax25_aton_entry (call, addr.axaddr.fsa_ax25.sax25_call.ax25_call);
if ((p_name = ax25_config_get_addr (p_port[port].name)) == NULL)
{
fprintf (stderr, "opn_sck() invalid port name %s\n", p_port[port].name);
close (p_port[port].fd);
clear_can (port);
return (0);
}
ax25_aton_entry (p_name, addr.axaddr.fsa_digipeater[0].ax25_call);
addrlen = sizeof (struct full_sockaddr_ax25);
break;
case CAN_NETROM:
printf ("CAN_NETROM\n");
if ((p_port[port].fd = socket (AF_NETROM, SOCK_SEQPACKET, 0)) < 0)
{
perror ("socket_r");
clear_can (port);
return (0);
}
/* Socket non bloquant */
ioc = 1;
ioctl (p_port[port].fd, FIONBIO, &ioc);
addr.axaddr.fsa_ax25.sax25_family = AF_NETROM;
addr.axaddr.fsa_ax25.sax25_ndigis = 0;
if ((p_name = nr_config_get_addr (p_port[port].name)) == NULL)
{
fprintf (stderr, "opn_sck() invalid port name %s\n", p_port[port].name);
close (p_port[port].fd);
clear_can (port);
return (0);
}
fprintf (stderr, "CAN_NETROM mycall %s myssid %d\n", mycall, myssid);
ax25_aton_entry (p_name, addr.axaddr.fsa_ax25.sax25_call.ax25_call);
addrlen = sizeof (struct full_sockaddr_ax25);
break;
case CAN_ROSE:
printf ("CAN_ROSE\n");
if ((p_port[port].fd = socket (AF_ROSE, SOCK_SEQPACKET, 0)) < 0)
{
perror ("socket_r");
clear_can (port);
return (0);
}
/* Socket non bloquant */
ioc = 1;
ioctl (p_port[port].fd, FIONBIO, &ioc);
addr.rsaddr.srose_family = AF_ROSE;
addr.rsaddr.srose_ndigis = 0;
sprintf (call, "%s-%d", mycall, myssid);
fprintf (stderr, "CAN_ROSE mycall %s myssid %d\n", mycall, myssid);
ax25_aton_entry (call, addr.rsaddr.srose_call.ax25_call);
if (is_rsaddr (p_port[port].name))
p_name = p_port[port].name;
else
{
if ((p_name = rs_config_get_addr (p_port[port].name)) == NULL)
{
fprintf (stderr, "opn_sck() invalid port name %s\n", p_port[port].name);
close (p_port[port].fd);
clear_can (port);
return (0);
}
}
rose_aton (p_name, addr.rsaddr.srose_addr.rose_addr);
addrlen = sizeof (struct sockaddr_rose);
break;
}
if (bind (p_port[port].fd, (struct sockaddr *) &addr, addrlen) == -1)
{
perror ("bind");
close (p_port[port].fd);
clear_can (port);
return (0);
}
if (listen (p_port[port].fd, SOMAXCONN) == -1)
{
perror ("listen");
close (p_port[port].fd);
clear_can (port);
return (0);
}
memset (&scan[0], 0, sizeof (scan_t));
}
sprintf (s, "Prog PORT %d COM%d-%d",
port, p_port[port].ccom, p_port[port].ccanal);
/* fprintf (stderr, "Prog PORT %d COM%d-%d\n",
port, p_port[port].ccom, p_port[port].ccanal);
*/
InitText (s);
return (ok);
}
/* Close port */
int cls_sck (int port)
{
int i;
for (i = 0; i < last_can; i++)
{
if (scan[i].sock > 0)
{
/* printf ("cls_sck : disconnect stream %d\n", i);
fprintf (stderr, "cls_sck : disconnect stream %d\n", i);
*/
close (scan[i].sock);
}
clear_can (i);
scan[i].state = DISCONNECT;
}
if (msocket > 0)
close (msocket);
msocket = -1;
if ((p_port[port].typort == TYP_SCK) && (p_port[port].fd))
{
close (p_port[port].fd);
clear_can (port);
}
return (1);
}
/*
* Static functions
*
*/
static int get_call (char *trame, char *buffer)
{
int c, i, ssid;
for (i = 0; i < 6; i++)
{
c = (*trame++) >> 1;
if (isalnum (c))
*buffer++ = c;
}
ssid = *trame;
if ((c = ((ssid >> 1) & 0xf)) != 0)
{
*buffer++ = '-';
if (c >= 10)
{
c -= 10;
*buffer++ = '1';
}
*buffer++ = c + '0';
}
*buffer = '\0';
return (ssid);
}
static int stop_cnx (int port)
{
if (p_port[port].fd) /* Prevent closing of 0 */
{
close(p_port[port].fd);
p_port[port].fd = 0;
}
return 1;
}
static int sock_rcv_ui (int *port, char *buffer, int *plen, ui_header * phead)
{
struct sockaddr sa;
struct ifreq ifr;
unsigned asize;
/* struct ifreq ifr; */
char buf[1500];
char temp[11];
char *via;
int lg, ssid, ssid_d, v2;
char ctrl;
char *ptr;
char *pctl;
int b_port;
int family;
/* int prevp;*/
char name[80];
memset(&sa, 0x00, sizeof(struct sockaddr));
memset(&ifr, 0x00, sizeof(struct ifreq));
memset(buf, 0, sizeof(buf));
memset(temp, 0, sizeof(temp));
memset(name, 0, sizeof(name));
do
{
b_port = *port;
asize = sizeof (sa);
lg = recvfrom (msocket, buf, 1500, 0, &sa, &asize);
if ((lg <= 0) || ((buf[0] & 0xf) != 0))
{
return (0);
}
strcpy (ifr.ifr_name, sa.sa_data);
if (ioctl (msocket, SIOCGIFHWADDR, &ifr) < 0)
{
perror ("GIFADDR");
return (0);
}
family = ifr.ifr_hwaddr.sa_family;
}
while ((family != AF_AX25) && (family != AF_NETROM) && (family != AF_ROSE));
if ((ptr = ax25_config_get_name (sa.sa_data)) != NULL)
{
strcpy(name, ptr);
b_port = name_to_port (ptr);
}
ptr = buf + 1;
--lg;
if (lg < 15)
return (FALSE);
memset (phead, 0, sizeof (ui_header));
via = phead->via;
if (lg > 300)
lg = 300;
ssid_d = get_call (ptr, phead->to);
ptr += 7;
ssid = get_call (ptr, phead->from);
ptr += 7;
v2 = ((ssid_d & 0x80) != (ssid & 0x80));
lg -= 14;
*via = '\0';
if ((ssid & 1) == 0)
{
do
{
lg -= 7;
if (lg < 1)
{
ff ();
return (0);
}
ssid = get_call (ptr, temp);
ptr += 7;
if (*temp)
{
strcat (via, temp);
if (ssid & 0x80)
{
if ((ssid & 1) || (((ssid & 1) == 0) && ((ptr[6] & 0x80) == 0)))
strcat (via, "*");
}
strcat (via, " ");
}
}
while ((ssid & 1) == 0);
}
ctrl = *ptr++;
lg--;
pctl = phead->ctl;
if ((ctrl & 0x1) == 0)
{
/* I frame */
*pctl++ = 'I';
*pctl++ = (ctrl >> 5) + '0';
*pctl++ = ((ctrl >> 1) & 0x7) + '0';
}
else if ((ctrl & 0x3) == 1)
{
/* S frame */
switch (ctrl & 0xf)
{
case 0x1:
*pctl++ = 'R';
*pctl++ = 'R';
break;
case 0x5:
*pctl++ = 'R';
*pctl++ = 'N';
*pctl++ = 'R';
break;
case 0x9:
*pctl++ = 'R';
*pctl++ = 'E';
*pctl++ = 'J';
break;
}
*pctl++ = (ctrl >> 5) + '0';
}
else
{
/* U frame */
switch (ctrl & 0xec)
{
case 0x2c:
*pctl++ = 'S';
*pctl++ = 'A';
*pctl++ = 'B';
*pctl++ = 'M';
break;
case 0x40:
*pctl++ = 'D';
*pctl++ = 'I';
*pctl++ = 'S';
*pctl++ = 'C';
break;
case 0x0c:
*pctl++ = 'D';
*pctl++ = 'M';
break;
case 0x60:
*pctl++ = 'U';
*pctl++ = 'A';
break;
case 0x84:
*pctl++ = 'F';
*pctl++ = 'R';
*pctl++ = 'M';
*pctl++ = 'R';
break;
case 0x00:
*pctl++ = 'U';
*pctl++ = 'I';
phead->ui = 1;
break;
}
}
if (v2)
{
if (ctrl & 0x10)
{
if (ssid_d & 0x80)
*pctl++ = '+';
else
*pctl++ = '-';
}
else
{
if (ssid_d & 0x80)
*pctl++ = '^';
else
*pctl++ = 'v';
}
}
else if (ctrl & 0x10)
*pctl++ = '!';
*pctl = '\0';
if (((ctrl & 1) == 0) || ((ctrl & 0xef) == 0x3))
{
lg--;
if (lg < 0)
{
return (0);
}
phead->pid = *ptr++ & 0xff;
}
else
phead->pid = 0;
/* prevp = b_port;*/
if (b_port == 0)
{
int bp;
switch (phead->pid)
{
case 0xcf:
/* Look for the port listening to this packet */
for (bp = 1; bp < NBPORT; bp++)
{
if ((p_port[bp].pvalid) && (p_port[bp].type == CAN_NETROM))
b_port = bp;
}
break;
case 0x01:
/* Look for the port listening to this packet */
for (bp = 1; bp < NBPORT; bp++)
{
if ((p_port[bp].pvalid) && (p_port[bp].type == CAN_ROSE))
b_port = bp;
}
break;
}
if (b_port == 0)
return (0);
}
/* Par securite ? */
if (lg < 0)
return (0);
if (lg > 256)
lg = 256;
*plen = lg;
if (lg)
sprintf (phead->txt, " (%d)", lg);
phead->port = *port = b_port;
memcpy (buffer, ptr, lg);
buffer[lg] = '\0';
return (1);
}
static int sock_snd_ui (int port, char *chaine, int len, Beacon * beacon)
{
char *calls[10];
char callsign[9];
char *ptr;
int dlen;
int slen;
struct full_sockaddr_ax25 dest;
struct full_sockaddr_ax25 src;
int i;
int nb;
int s;
memset(&src, 0x00, sizeof(struct full_sockaddr_ax25));
memset(&dest, 0x00, sizeof(struct full_sockaddr_ax25));
nb = 0;
calls[nb] = malloc (AX25_CALLSID);
sprintf (calls[nb++], "%s-%d", beacon->desti.call, beacon->desti.num);
for (i = 0; i < beacon->nb_digi; i++)
{
calls[nb] = malloc (AX25_CALLSID);
sprintf (calls[nb++], "%s-%d", beacon->digi[i].call, beacon->digi[i].num);
}
calls[nb] = NULL;
if ((dlen = ax25_aton_arglist ((const char **)calls, &dest)) == -1)
{
fprintf (stderr, "beacon: unable to convert callsign '%s'\n", calls[0]);
return 0;
}
for (i = 0; calls[i]; i++)
free (calls[i]);
sprintf (callsign, "%s-%d", mycall, myssid);
slen = ax25_aton (callsign, &src);
ptr = ax25_config_get_addr (p_port[port].name);
if (ptr == NULL)
return (0);
ax25_aton_entry (ptr, src.fsa_digipeater[0].ax25_call);
src.fsa_ax25.sax25_ndigis = 1;
if ((s = socket (AF_AX25, SOCK_DGRAM, 0)) == -1)
{
perror ("beacon: socket");
return 0;
}
if (bind (s, (struct sockaddr *) &src, slen) == -1)
{
perror ("beacon: bind");
return 0;
}
if (sendto (s, chaine, len, 0, (struct sockaddr *) &dest, dlen) == -1)
{
perror ("beacon: sendto");
return 0;
}
close (s);
return (1);
}
static int sock_snd_dt (int canal, char *buffer, int len)
{
int nb;
if (scan[canal].sock <= 0)
return (FALSE);
nb = write (scan[canal].sock, buffer, len);
if (nb == -1)
{
/* fprintf (stderr, "sock_snd_dt() Error %d on socket %d\n", errno, scan[canal].sock);*/
/* perror ("sock_snd_dt() : write on socket");*/
return (FALSE);
}
else if (nb < len)
{
/* fprintf (stderr, "Cannot write %d bytes on socket %d\n", len - nb, scan[canal].sock);*/
perror ("Cannot write ?? bytes on socket\n");
return (FALSE);
}
return (TRUE);
}
static int sock_cmd (int port, int canal, char *cmd)
{
/* Dave van der Locht 27-01-2020
Why clearing scan[canal].source? The second call to this function, after the I command,
forces the gateway to use the BBS's own callsign as FROM address.
*/
//strcpy (scan[canal].source, "\0") ;
switch (*cmd++)
{
case 'I':
/* source callsign */
while (isspace (*cmd))
++cmd;
strn_cpy (AX25_CALLSID, scan[canal].source, cmd);
break;
case 'D':
/* Deconnection */
if (scan[canal].sock > 0)
{
close (scan[canal].sock);
/* clear_can (canal); */
scan[canal].sock = -1;
}
break;
case 'C':
/* Connection */
while (isspace (*cmd))
++cmd;
scan[canal].paclen = p_port[port].pk_t;
scan[canal].maxframe = p_port[port].frame;
scan[canal].port = port;
scan[canal].type = p_port[port].type;
sock_connect (cmd, canal);
break;
default:
return (0);
}
return (1);
}
static int nr_ax25_aton (char *address, struct full_sockaddr_ax25 *addr)
{
char buffer[100], *call, *alias;
FILE *fp;
int addrlen;
memset(buffer, 0, sizeof(buffer));
call = address;
while (*call)
{
if (isspace (*call))
{
*call = '\0';
break;
}
*call = toupper (*call);
++call;
}
if ((fp = fopen ("/proc/net/nr_nodes", "r")) == NULL)
{
fprintf (stderr, "call: NET/ROM not included in the kernel\n");
return -1;
}
while (fgets (buffer, 100, fp) != NULL)
{
call = strtok (buffer, " \t\n\r");
alias = strtok (NULL, " \t\n\r");
if (strcmp (address, call) == 0 || strcmp (address, alias) == 0)
{
addrlen = ax25_aton (call, addr);
addr->fsa_ax25.sax25_family = AF_NETROM;
fclose (fp);
return (addrlen == -1) ? -1 : sizeof (struct sockaddr_ax25);
}
}
fclose (fp);
/* fprintf (stderr, "call: NET/ROM callsign or alias not found\n");*/
return -1;
}
static int rs_ax25_aton (char *address, struct sockaddr_rose *addr)
{
char *command, *call, *rsaddr, *digi;
command = strdup (address);
if (command)
{
char roseaddr[12];
call = strtok (command, " ,\t\n\r");
addr->srose_family = AF_ROSE;
addr->srose_ndigis = 0;
if (ax25_aton_entry (call, addr->srose_call.ax25_call) == -1)
{
free (command);
return -1;
}
rsaddr = strtok (NULL, " \t\r\n");
if (rsaddr == NULL)
{
free (command);
return -1;
}
/* DNIC / Address */
if (strlen (rsaddr) == 10)
strcpy (roseaddr, rsaddr);
else if (strlen (rsaddr) == 4)
{
strcpy (roseaddr, rsaddr);
rsaddr = strtok (NULL, " \t\r\n");
if ((rsaddr == NULL) || (strlen (rsaddr) != 6))
{
free (command);
return -1;
}
strcpy (roseaddr + 4, rsaddr);
}
if (rose_aton (roseaddr, addr->srose_addr.rose_addr) == -1)
{
free (command);
return -1;
}
/* Digis */
while ((digi = strtok (NULL, " \t\r\n")) != NULL)
{
#if 0
if (ax25_aton_entry (digi, addr->srose_digis[addr->srose_ndigis].ax25_call) == -1)
{
free (command);
return -1;
}
if (++addr->srose_ndigis == 6)
break;
#else
if (ax25_aton_entry (digi, addr->srose_digi.ax25_call) == -1)
{
free (command);
return -1;
}
if (++addr->srose_ndigis == 1)
break;
#endif
}
free (command);
}
return sizeof (struct sockaddr_rose);
}
static int sock_connect (char *commande, int can)
{
int fd;
int addrlen;
int t1 = 50;
/* int retry = 3; */
/* int one = debug; */
int ioc;
union sockaddr_ham addr;
char *p_name = NULL;
char mycallsign[AX25_CALLSID];
int backoff = 0;
memset(&addr, 0x00, sizeof(struct full_sockaddr_ax25));
memset(mycallsign, 0, sizeof(mycallsign));
if (strcmp(scan[can].source,"") != 0 )
{
strcpy (mycallsign, scan[can].source);
/* fprintf (stderr, "sock_connect() scan[can].source '%s'\n", scan[can].source);*/
}
else
{
sprintf (mycallsign, "%s-%d", mycall, myssid);
/* fprintf (stderr, "sock_connect() mycall '%s' myssid '%d'\n", mycall, myssid);*/
}
/* fprintf (stderr, "sock_connect() mycallsign '%s'\n", mycallsign);*/
switch (scan[can].type)
{
case CAN_AX25:
if ((fd = socket (AF_AX25, SOCK_SEQPACKET, 0)) < 0)
{
perror ("socket_ax");
clear_can (can);
return (0);
}
addr.axaddr.fsa_ax25.sax25_family = AF_AX25;
addr.axaddr.fsa_ax25.sax25_ndigis = 1;
if ((p_name = ax25_config_get_addr (p_port[scan[can].port].name)) == NULL)
{
fprintf (stderr, "sock_connect() invalid port name %s\n", p_port[scan[can].port].name);
close (fd);
clear_can (can);
return (0);
}
ax25_aton_entry (mycallsign, addr.axaddr.fsa_ax25.sax25_call.ax25_call);
ax25_aton_entry (p_name, addr.axaddr.fsa_digipeater[0].ax25_call);
addrlen = sizeof (struct full_sockaddr_ax25);
if (setsockopt (fd, SOL_AX25, AX25_WINDOW, &scan[can].maxframe, sizeof (scan[can].maxframe)) == -1)
{
perror ("AX25_WINDOW");
close (fd);
clear_can (can);
return (0);
}
if (setsockopt (fd, SOL_AX25, AX25_PACLEN, &scan[can].paclen, sizeof (scan[can].paclen)) == -1)
{
perror ("AX25_PACLEN");
close (fd);
clear_can (can);
return (0);
}
t1 = 5;
if (setsockopt (fd, SOL_AX25, AX25_T1, &t1, sizeof (t1)) == -1)
{
perror ("AX25_T1");
close (fd);
clear_can (can);
return (0);
}
/*
if (setsockopt (fd, SOL_AX25, AX25_N2, &retry, sizeof (retry)) == -1)
{
perror ("AX25_N2");
close (fd);
clear_can (can);
return (0);
}
*/
if (backoff != -1)
{
if (setsockopt (fd, SOL_AX25, AX25_BACKOFF, &backoff, sizeof (backoff)) == -1)
{
perror ("AX25_BACKOFF");
close (fd);
clear_can (can);
return (0);
}
}
/*
if (ax25mode != -1)
{
if (setsockopt (fd, SOL_AX25, AX25_EXTSEQ, &ax25mode, sizeof (ax25mode)) == -1)
{
perror ("AX25_EXTSEQ");
close (fd);
clear_can (can);
return (0);
}
}
*/
break;
case CAN_NETROM:
if ((fd = socket (AF_NETROM, SOCK_SEQPACKET, 0)) < 0)
{
perror ("socket_nr");
clear_can (can);
return (0);
}
addr.axaddr.fsa_ax25.sax25_family = AF_NETROM;
addr.axaddr.fsa_ax25.sax25_ndigis = 1;
if ((p_name = nr_config_get_addr (p_port[scan[can].port].name)) == NULL)
{
fprintf (stderr, "sock_connect() invalid port name %s\n", p_port[scan[can].port].name);
close (fd);
clear_can (can);
return (0);
}
ax25_aton_entry (p_name, addr.axaddr.fsa_ax25.sax25_call.ax25_call);
ax25_aton_entry (mycallsign, addr.axaddr.fsa_digipeater[0].ax25_call);
addrlen = sizeof (struct full_sockaddr_ax25);
/* if (setsockopt (fd, SOL_NETROM, NETROM_PACLEN, &scan[can].paclen, sizeof (scan[can].paclen)) == -1)
{
perror ("NETROM_PACLEN");
close (fd);
clear_can (can);
return (0);
} */
break;
case CAN_ROSE:
if ((fd = socket (AF_ROSE, SOCK_SEQPACKET, 0)) < 0)
{
perror ("socket_rs");
clear_can (can);
return (0);
}
addr.rsaddr.srose_family = AF_ROSE;
addr.rsaddr.srose_ndigis = 0;
if (is_rsaddr (p_port[scan[can].port].name))
p_name = p_port[scan[can].port].name;
else
{
if ((p_name = rs_config_get_addr (p_port[scan[can].port].name)) == NULL)
{
fprintf (stderr, "sock_connect() invalid port name %s\n", p_port[scan[can].port].name);
close (fd);
clear_can (can);
return (0);
}
}
rose_aton (p_name, addr.rsaddr.srose_addr.rose_addr);
ax25_aton_entry (mycallsign, addr.rsaddr.srose_call.ax25_call);
addrlen = sizeof (struct sockaddr_rose);
break;
default:
return FALSE;
}
/*
if (debug && setsockopt (fd, SOL_SOCKET, SO_DEBUG, &one, sizeof (one)) == -1)
{
perror ("SO_DEBUG");
close (fd);
clear_can (can);
return (0);
}
*/
scan[can].state = CPROGRESS;
if (bind (fd, (struct sockaddr *) &addr, addrlen) == -1)
{
perror ("sock_connect : bind");
close (fd);
/* clear_can (can); */
scan[can].sock = -1;
return (TRUE);
}
switch (scan[can].type)
{
case CAN_AX25:
if ((addrlen = ax25_aton (commande, &addr.axaddr)) == -1)
{
close (fd);
/* clear_can (can); */
scan[can].sock = -1;
return (0);
}
break;
case CAN_NETROM:
if ((addrlen = nr_ax25_aton (commande, &addr.axaddr)) == -1)
{
close (fd);
/* clear_can (can); */
scan[can].sock = -1;
return (TRUE);
}
break;
case CAN_ROSE:
if ((addrlen = rs_ax25_aton (commande, &addr.rsaddr)) == -1)
{
close (fd);
/* clear_can (can); */
scan[can].sock = -1;
return (TRUE);
}
break;
}
ioc = 1;
ioctl (fd, FIONBIO, &ioc);
if (connect (fd, (struct sockaddr *) &addr, addrlen) == -1)
{
if (errno != EINPROGRESS)
{
perror ("connect");
close (fd);
/* clear_can (can); */
fd = -1;
}
}
scan[can].sock = fd;
return (TRUE);
}
static int sock_stat (int canal, stat_ch * ptr)
{
unsigned lg;
int val;
int tries = 0;
/*
* valid when ROSE is patched for
* ax25_info_new structure
*/
struct ax25_info_struct ax25info;
memset(&ax25info, 0x00, sizeof(struct ax25_info_struct));
/* struct ax25_info_struct_new ax25info;
*/
if (scan[canal].sock <= 0)
{
ptr->ack = 0;
ptr->ret = 0;
return (0);
}
ptr->mem = 100;
val = s_free (&scan[canal]);
if (scan[canal].state == DISCONNECT)
{
ptr->ack = 0;
ptr->ret = 0;
}
else if (scan[canal].state != CONNECTED)
ptr->ack = 0;
else
{
ptr->ack = (scan[canal].queue - val) / scan[canal].paclen;
if ((scan[canal].queue - val) && (ptr->ack == 0))
ptr->ack = 1;
}
if (scan[canal].type == CAN_AX25)
{
/*
* valid when ROSE will be patched for
* ax25_info_new structure
*
* if (ioctl (scan[canal].sock, SIOCAX25GETINFONEW, &ax25info) == 0)
*
*/
if (ioctl (scan[canal].sock, SIOCAX25GETINFO, &ax25info) == 0)
{
ptr->ret = ax25info.n2count;
/* fprintf(stderr, "n2=%d n2t=%d send=%d recv=%d\n",
ax25info.n2, ax25info.n2count,
ax25info.snd_q, ax25info.rcv_q); */
}
else
{
lg = sizeof (int);
#ifdef AX25_N2COUNT
if (getsockopt (scan[canal].sock, SOL_AX25, AX25_N2COUNT, &tries, &lg) <= 0)
{
#endif
if (getsockopt (scan[canal].sock, SOL_AX25, AX25_N2, &tries, &lg) <= 0)
{
/* perror("getsockopt : AX25_N2"); */
}
#ifdef AX25_N2COUNT
}
#endif
ptr->ret = tries;
}
}
else
{
ptr->ret = 0; /* XXX */
}
return (1);
}
static int s_status (scan_t * can)
{
int nb;
int res = 0;
fd_set sock_read;
fd_set sock_write;
fd_set sock_excep;
struct timeval to;
if (can->sock <= 0)
return (0);
to.tv_sec = to.tv_usec = 0;
can->event = 0;
FD_ZERO (&sock_read);
FD_ZERO (&sock_write);
FD_ZERO (&sock_excep);
FD_SET (can->sock, &sock_read);
FD_SET (can->sock, &sock_write);
FD_SET (can->sock, &sock_excep);
nb = select (can->sock + 1, &sock_read, &sock_write, &sock_excep, &to);
if (nb == -1)
{
perror ("select");
return (res);
}
else if (nb == 0)
{
return (res);
}
else
{
if (FD_ISSET (can->sock, &sock_read))
{
res |= READ_EVENT;
}
if (FD_ISSET (can->sock, &sock_write))
{
if (can->state == CPROGRESS)
{
/*F6BVP nb = write (can->sock, &res, 0);
printf ("nb = %d\n", nb);
if (nb != -1)
{ */
can->state = CONNECTED;
can->event = CONN_EVENT;
/* } */
res |= EXCEPT_EVENT;
}
else
res |= WRITE_EVENT;
}
if (FD_ISSET (can->sock, &sock_excep))
{
printf ("Exception sur %d\n", can->sock);
can->event = NO_EVENT;
res |= EXCEPT_EVENT;
}
}
return (res);
}
static int sock_paclen (int canal)
{
if (scan[canal].sock <= 0)
return (0);
return (scan[canal].paclen);
}
static int s_free (scan_t * can)
{
int queue_free;
if (ioctl (can->sock, TIOCOUTQ, &queue_free) == -1)
{
perror ("ioctl : TIOCOUTQ");
return (0);
}
return (queue_free);
}
static char *ax25_ntoaddr (char *peer, const ax25_address * axa)
{
strcpy(peer, _ax25_ntoa(axa));
return peer;
}
static char *rose_ntoaddr (char *peer, const rose_address * rsa)
{
strcpy(peer, rose_ntoa(rsa)+4);
return peer;
}
static char *rose_ntodnic (char *peer, const rose_address * rsa)
{
strncpy(peer, rose_ntoa(rsa), 4);
peer[4] = '\0';
return peer;
}
static int name_to_port (char *port)
{
int i;
for (i = 1; i < NBPORT; i++)
{
if (strcmp (port, p_port[i].name) == 0)
return (i);
}
/* printf("Port <%s> not found in port.sys\n", port); */
return (0);
}
static int sock_connexion (int new, int can, union sockaddr_ham *addr, int *port, char *buffer)
{
int p;
int val;
unsigned plen;
int backoff;
char *pn = NULL;
char User[80];
char Node[80];
char Dnic[80];
union sockaddr_ham addrham;
memset(&addrham, 0x00, sizeof(struct full_sockaddr_ax25));
scan[can].state = CONNECTED;
scan[can].sock = new;
if (scan[can].port == 0)
{
plen = sizeof (addrham);
if (getsockname (scan[can].sock, (struct sockaddr *) &addrham, &plen) == 0)
{
switch (addrham.axaddr.fsa_ax25.sax25_family)
{
case AF_AX25:
scan[can].type = CAN_AX25;
pn = ax25_config_get_port (&addrham.axaddr.fsa_digipeater[0]);
break;
case AF_NETROM:
scan[can].type = CAN_NETROM;
pn = nr_config_get_port (&addrham.axaddr.fsa_ax25.sax25_call);
break;
case AF_ROSE:
scan[can].type = CAN_ROSE;
pn = rs_config_get_port (&addrham.rsaddr.srose_addr);
break;
}
scan[can].port = (pn) ? name_to_port (pn) : *port;
/* fprintf (stderr, "Connection received on port %s = %d\n", pn, scan[can].port);*/
if (scan[can].port == 0)
{
close (new);
clear_can (can);
return (0);
}
}
else
scan[can].port = *port;
}
scan[can].queue = s_free (&scan[can]);
*port = p = scan[can].port;
val = p_port[p].pk_t;
if (val == 0)
val = 128;
scan[can].paclen = val;
switch (scan[can].type)
{
case CAN_AX25:
if (setsockopt (new, SOL_AX25, AX25_PACLEN, &val, sizeof (val)) == -1)
{
perror ("setsockopt : AX25_PACLEN");
close (new);
clear_can (can);
return (0);
}
backoff = 0;
if (setsockopt (new, SOL_AX25, AX25_BACKOFF, &backoff, sizeof (backoff)) == -1)
{
perror ("setsockopt : AX25_BACKOFF");
close (new);
clear_can (can);
return (0);
}
/* Look for informations on the connection */
ax25_ntoaddr (User, &addr->axaddr.fsa_ax25.sax25_call);
sprintf (buffer, "(%d) CONNECTED to %d:%s", can, p, User);
/* fprintf (stderr, "(%d) CONNECTED to %d:%s\n", can, p, User);*/
if (addr->axaddr.fsa_ax25.sax25_ndigis)
{
int i;
char c_digi[AX25_CALLSID + 1];
strcat (buffer, " via");
for (i = 0; i < addr->axaddr.fsa_ax25.sax25_ndigis; i++)
{
c_digi[0] = ' ';
ax25_ntoaddr (c_digi + 1, &addr->axaddr.fsa_digipeater[i]);
strcat (buffer, c_digi);
}
}
break;
case CAN_NETROM:
/* if (setsockopt(new, SOL_NETROM, NETROM_PACLEN, &val, sizeof(val)) == -1)
{
perror("setsockopt : NETROM_PACLEN");
close (new);
clear_can (can);
return(0);
} */
/* Look for informations on the connection */
ax25_ntoaddr (User, &addr->axaddr.fsa_ax25.sax25_call);
ax25_ntoaddr (Node, &addr->axaddr.fsa_digipeater[0]);
sprintf (buffer, "(%d) CONNECTED to %d:%s via %s", can, p, User, Node);
/* fprintf (stderr, "(%d) CONNECTED to %d:%s via %s\n", can, p, User, Node);
*/
break;
case CAN_ROSE:
/* Look for informations on the connection */
rose_ntodnic (Dnic, &addr->rsaddr.srose_addr);
rose_ntoaddr (Node, &addr->rsaddr.srose_addr);
ax25_ntoaddr (User, &addr->rsaddr.srose_call);
sprintf (buffer, "(%d) CONNECTED to %d:%s via %s %s", can, p, User, Dnic, Node);
/* fprintf (stderr, "(%d) CONNECTED to %d:%s via %s %s\n", can, p, User, Dnic, Node);
*/ break;
}
return (TRUE);
}
static void clear_can (int canal)
{
/* fprintf (stderr, "(%d) drv_sock : clear_can()\n", canal);*/
memset (&scan[canal], 0, sizeof (scan_t));
scan[canal].sock = -1;
scan[canal].state = DISCONNECT;
}
static int is_rsaddr (char *addr)
{
int n = 0;
while (addr[n])
{
if (!isdigit (addr[n]))
return (0);
++n;
}
return (n == 10);
}
fbb-7.0.11/src/warning.c 0000664 0001750 0001750 00000011103 13613525371 011656 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
#include
/* Module gerant les messages "warning" */
/*
* Demande de message warning :
*
* 1 - PingPong
* 2 - Route inconnue
* 3 - NTS inconnu
*
*/
void dde_warning (int type)
{
pvoie->warning |= type;
}
void tst_warning (bullist * ptmes)
{
char wtexte[256];
char nom[128];
unsigned warning = pvoie->warning;
while (warning)
{
if (warning & W_PPG)
{
#ifdef ENGLISH
sprintf (wtexte,
"Duplicate reverse forward of # %ld to %s, route to %s",
ptmes->numero, ptmes->desti, ptmes->bbsv
);
if (w_mask & W_PINGPONG)
mess_warning (admin, "*** PING-PONG ***", wtexte);
#else
sprintf (wtexte,
"Presentation en retour du # %ld a %s, routage vers %s",
ptmes->numero, ptmes->desti, ptmes->bbsv
);
if (w_mask & W_PINGPONG)
mess_warning (admin, "*** PING-PONG ***", wtexte);
#endif
warning &= ~(W_PPG);
}
else if (warning & W_ROU)
{
#ifdef ENGLISH
sprintf (wtexte,
"Unknown route to %s. \rMessage #%ld written by %s received %s \r",
ptmes->bbsv, ptmes->numero,
ptmes->exped, strdate (time (NULL))
);
if (w_mask & W_NO_ROUTE)
mess_warning (admin, "*** UNKNOWN ROUTE *** ", wtexte);
#else
sprintf (wtexte,
"Acheminement vers %s inconnu.\rMessage %ld demande par %s recu le %s\r",
ptmes->bbsv, ptmes->numero,
ptmes->exped, strdate (time (NULL))
);
if (w_mask & W_NO_ROUTE)
mess_warning (admin, "*** ACHEMINEMENT INCONNU ***", wtexte);
#endif
warning &= ~(W_ROU);
}
else if (warning & W_NTS)
{
#ifdef ENGLISH
sprintf (wtexte,
"Unknown NTS %s. \rMessage #%ld written by %s received %s\r",
ptmes->desti, ptmes->numero,
ptmes->exped, strdate (time (NULL))
);
if (w_mask & W_NO_NTS)
mess_warning (admin, "*** UNKNOWN NTS ***", wtexte);
#else
sprintf (wtexte,
"NTS %s inconnu.\rMessage %ld demande par %s recu le %s \r",
ptmes->desti, ptmes->numero,
ptmes->exped, strdate (time (NULL))
);
if (w_mask & W_NO_NTS)
mess_warning (admin, "*** NTS INCONNU ***", wtexte);
#endif
warning &= ~(W_NTS);
}
else if (warning & W_ASC)
{
mess_name (MESSDIR, ptmes->numero, nom);
#ifdef ENGLISH
sprintf (wtexte,
"Ascii file %s not found \r", nom
);
if (w_mask & W_MESSAGE)
mess_warning (admin, "*** ASCII FILE NOT FOUND ***", wtexte);
#else
sprintf (wtexte,
"Fichier ascii %s pas trouve\r", nom
);
if (w_mask & W_MESSAGE)
mess_warning (admin, "*** ERREUR FICHIER ASCII ***", wtexte);
#endif
warning &= ~(W_ASC);
}
else if (warning & W_BIN)
{
mess_name (MBINDIR, ptmes->numero, nom);
#ifdef ENGLISH
sprintf (wtexte,
"Binary file %s not found \r", nom
);
if (w_mask & W_MESSAGE)
mess_warning (admin, "*** BIN FILE NOT FOUND ***", wtexte);
#else
sprintf (wtexte,
"Fichier binaire %s pas trouve\r", nom
);
if (w_mask & W_MESSAGE)
mess_warning (admin, "*** ERREUR FICHIER BIN ***", wtexte);
#endif
warning &= ~(W_BIN);
}
}
pvoie->warning = 0;
}
void mess_warning (char *w_desti, char *w_titre, char *w_texte)
{
int nb, sav_voie = voiecur, sav_lang = vlang;
if (voiecur == MWARNING)
return; /* Deja en warning */
deb_io ();
selvoie (MWARNING);
if (FOR (svoie[sav_voie]->mode))
pvoie->mode |= F_FOR;
entete_saisie ();
ini_champs (voiecur);
strn_cpy (6, ptmes->desti, w_desti);
strcpy (ptmes->exped, mycall);
ptmes->type = 'P';
swapp_bbs (ptmes);
reacheminement ();
strn_cpy (60, ptmes->titre, w_titre);
pvoie->mode = F_FOR;
nb = strlen (w_texte);
w_texte[nb] = '\032';
get_mess_fwd ('\0', w_texte, nb + 1, 2);
selvoie (sav_voie);
vlang = sav_lang;
fin_io ();
}
fbb-7.0.11/src/nomenc.c 0000664 0001750 0001750 00000026126 13613525371 011503 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
/*
* MODULE NOMENC.C
*/
#include
static int ecrire_indic (tri *, int);
static void affich_nom (info *);
static void menu_nomenclature (void);
static void fin_liste_indic (void);
static void parcours_liste (void);
static void affich_indic (info * pinfo)
{
int i = 0;
char s[40];
sprintf (varx[0], "%-6s-%d", pinfo->indic.call, pinfo->indic.num);
texte (T_NOM + 3);
if (*(pinfo->relai[i].call))
{
out ("via ", 4);
while ((i < 8) && *(pinfo->relai[i].call))
{
if (i == 4)
out ("$W ", 6);
sprintf (s, " %-6s-%d", pinfo->relai[i].call, pinfo->relai[i].num);
out (s, strlen (s));
++i;
}
out ("$W", 2);
}
}
static void affich_coord (info * pinfo)
{
affich_indic (pinfo);
affich_nom (pinfo);
ptmes->date = pinfo->hcon;
texte (T_NOM + 4);
}
static void affich_nom (info * pinfo)
{
var_cpy (0, pinfo->nom);
var_cpy (1, pinfo->prenom);
var_cpy (2, pinfo->adres);
var_cpy (3, pinfo->ville);
var_cpy (4, pinfo->qra);
var_cpy (5, pinfo->teld);
var_cpy (6, pinfo->telp);
var_cpy (7, pinfo->home);
var_cpy (8, pinfo->zip);
texte (T_NOM + 5);
}
static void rech_nomenc (void)
{
unsigned r;
FILE *fptr;
info buf_info;
*varx[0] = '\0';
if (*indd == '\0')
{
texte (T_NOM + 3);
}
else
{
if (find (sup_ln (indd)))
{
if ((r = chercoord (indd)) == 0xffff)
{
var_cpy (0, indd);
texte (T_NOM + 13);
}
else
{
fptr = ouvre_nomenc ();
fseek (fptr, (long) r * sizeof (info), 0);
fread ((char *) &buf_info, sizeof (info), 1, fptr);
ferme (fptr, 11);
affich_coord (&buf_info);
}
maj_niv (5, 0, 0);
prompt (pvoie->finf.flags, pvoie->niv1);
}
else
{
var_cpy (0, indd);
texte (T_NOM + 13);
maj_niv (5, 0, 0);
prompt (pvoie->finf.flags, pvoie->niv1);
}
}
}
static void lit_coord (unsigned record, info * frec)
{
FILE *fptr;
fptr = ouvre_nomenc ();
fseek (fptr, (long) record * sizeof (info), 0);
fread (frec, sizeof (info), 1, fptr);
ferme (fptr, 39);
}
static void ecrit_coord (unsigned record, info * frec)
{
FILE *fptr;
if (record == 0xffff)
dump_core ();
fptr = ouvre_nomenc ();
fseek (fptr, (long) record * sizeof (info), 0);
fwrite (frec, sizeof (info), 1, fptr);
ferme (fptr, 39);
}
static void modif_nomenc (void)
{
unsigned num_indic;
int err = 0;
info frec;
char c;
char s[80];
char temp[80];
char *ptr;
char *scan;
if (read_only ())
{
prompt (pvoie->finf.flags, pvoie->niv1);
maj_niv (5, 0, 0);
return;
}
if (pvoie->niv3 > 1)
lit_coord (pvoie->emis->coord, &frec);
switch (pvoie->niv3)
{
case 0:
incindd ();
if ((*indd) && (droits (COSYSOP)))
{
if (find (sup_ln (indd)))
{
pvoie->emis = insnoeud (indd, &num_indic);
if (pvoie->emis->coord == 0xffff)
err = 1;
}
else
err = 1;
if (err)
{
var_cpy (0, indd);
texte (T_NOM + 13);
prompt (pvoie->finf.flags, pvoie->niv1);
maj_niv (5, 0, 0);
return;
}
}
else
{
pvoie->emis = pvoie->ncur;
}
lit_coord (pvoie->emis->coord, &frec);
affich_nom (&frec);
texte (T_QST + 1);
ch_niv3 (1);
break;
case 1:
c = toupper (*indd);
if (c == Oui)
{
/* majinfo(voiecur, 1) ; */
texte (T_MBL + 9);
ch_niv3 (2);
}
else if ((c == 'A') || (c == 'F') || (c == Non))
{
maj_niv (5, 0, 0);
incindd ();
menu_nomenclature ();
}
else
{
texte (T_ERR + 0);
texte (T_QST + 1);
}
break;
case 2:
if (ISGRAPH (*indd))
{
epure (frec.prenom, 12);
scan = frec.prenom;
while (*scan)
{
if (*scan == ' ')
*scan = '-';
++scan;
}
}
texte (T_NOM + 6);
ch_niv3 (3);
break;
case 3:
if (ISGRAPH (*indd))
epure (frec.nom, 17);
texte (T_NOM + 7);
ch_niv3 (4);
break;
case 4:
if (ISGRAPH (*indd))
epure (frec.adres, 60);
texte (T_MBL + 54);
ch_niv3 (5);
break;
case 5:
if (ISGRAPH (*indd))
{
epure (frec.zip, 8);
scan = frec.zip;
while (*scan)
{
if (*scan == ' ')
*scan = '-';
++scan;
}
}
texte (T_NOM + 8);
ch_niv3 (6);
break;
case 6:
if (ISGRAPH (*indd))
epure (frec.ville, 30);
texte (T_NOM + 9);
ch_niv3 (7);
break;
case 7:
if (ISGRAPH (*indd))
epure (frec.teld, 12);
texte (T_NOM + 10);
ch_niv3 (8);
break;
case 8:
if (ISGRAPH (*indd))
epure (frec.telp, 12);
texte (T_MBL + 53);
ch_niv3 (9);
break;
case 9:
if (ISGRAPH (*indd))
{
strupr (epure (s, 40));
ptr = strchr (s, '.');
if (ptr)
*ptr = '\0';
ptr = strchr (s, '-');
if (ptr)
{
*ptr = '\0';
}
strcpy (temp, s);
if (find (temp))
{
strcpy (frec.home, s);
texte (T_NOM + 11);
ch_niv3 (10);
}
else
{
texte (T_ERR + 7);
texte (T_MBL + 53);
}
}
else
{
texte (T_NOM + 11);
ch_niv3 (10);
}
break;
case 10:
if (ISGRAPH (*indd))
{
strupr (epure (s, 6));
if (tstqra (s))
{
strcpy (frec.qra, s);
ecrit_coord (pvoie->emis->coord, &frec);
}
else
{
texte (T_NOM + 11);
break;
}
}
user_wp (&frec);
texte (T_QST + 2);
prompt (pvoie->finf.flags, pvoie->niv1);
maj_niv (5, 0, 0);
break;
default:
fbb_error (ERR_NIVEAU, "MODIF-NOMENC", pvoie->niv3);
break;
}
if (pvoie->niv3 > 2)
{
ecrit_coord (pvoie->emis->coord, &frec);
if (pvoie->emis == pvoie->ncur)
pvoie->finf = frec;
}
}
/*
* LISTE DES INDICATIFS
*/
static void fin_liste_indic (void)
{
itoa (pvoie->temp1, varx[0], 10);
texte (T_NOM + 12);
}
int ecrire_indic (tri * inf_ptr, int nb)
/*
* en sortie : vrai si l'indicatif a ete ecrit
* faux sinon
*/
{
char s[81];
bloc_indic *temp;
int ind, val;
int i, j, pos = 0;
for (i = 0; i < nb; i++)
{
ind = 0;
val = inf_ptr->pos;
if (val == 0)
break;
temp = racine;
while ((ind + T_BLOC_INFO) <= val)
{
ind += T_BLOC_INFO;
temp = temp->suiv;
}
j = val - ind;
sprintf (s, "%-6s ", temp->st_ind[j].indic);
out (s, strlen (s));
if (++pos == 11)
{
pos = 0;
out ("\n", 1);
}
++inf_ptr;
}
return (TRUE);
}
static void parcours_liste (void)
{
bloc_indic *bptr;
tri *inf_ptr = NULL, *pos_ptr = NULL;
unsigned offset;
unsigned num_indic;
int pass;
int nb = 0;
tri t_ptr;
pvoie->temp1 = 0;
for (pass = 0; pass <= 1; ++pass)
{
bptr = racine;
offset = num_indic = 0;
if (pass == 0)
pos_ptr = &t_ptr;
while (bptr)
{
if (*(bptr->st_ind[offset].indic) == '\0')
break;
if (bptr->st_ind[offset].coord != 0xffff)
{
if (bptr->st_ind[offset].val)
{
if (strmatch (bptr->st_ind[offset].indic, indd))
{
if (pass)
{
pos_ptr->pos = num_indic;
n_cpy (6, pos_ptr->ind, bptr->st_ind[offset].indic);
++pos_ptr;
}
++nb;
}
}
}
if (++offset == T_BLOC_INFO)
{
offset = 0;
bptr = bptr->suiv;
}
++num_indic;
}
if (nb == 0)
break;
if (pass == 0)
{
pvoie->temp1 = nb;
pos_ptr = inf_ptr = (tri *) m_alloue (nb * sizeof (tri));
nb = 0;
}
}
if (nb)
qsort ((void *) inf_ptr, (size_t) nb, (size_t) sizeof (tri), (int (*)(const void *, const void *)) strcmp);
ecrire_indic (inf_ptr, nb);
if (nb)
m_libere (inf_ptr, nb * sizeof (tri));
}
void liste_indic (void)
{
pvoie->temp2 = pvoie->temp1 = 0;
strupr (sup_ln (indd));
if (*indd == '\0')
{
*indd = '*';
*(indd + 1) = '\0';
}
parcours_liste ();
fin_liste_indic ();
retour_menu (pvoie->niv1);
}
void saisie_infos (void)
{
int change = 0;
char s[80];
char temp[80];
char *ptr;
char *scan;
switch (pvoie->niv3)
{
case 0:
break;
case 1:
if (ISGRAPH (*indd))
{
epure (pvoie->finf.prenom, 12);
scan = pvoie->finf.prenom;
while (*scan)
{
if (*scan == ' ')
*scan = '-';
++scan;
}
change = 1;
}
break;
case 2:
if (ISGRAPH (*indd))
{
epure (pvoie->finf.ville, 30);
change = 1;
}
break;
case 3:
if (ISGRAPH (*indd))
{
strupr (epure (s, 40));
/* Seul l'indicatif est enregistre */
ptr = strchr (s, '.');
if (ptr)
*ptr = '\0';
ptr = strchr (s, '-');
if (ptr)
{
*ptr = '\0';
}
strcpy (temp, s);
if (find (temp))
{
strcpy (pvoie->finf.home, extend_bbs (s));
}
else
{
texte (T_ERR + 7);
}
change = 1;
}
break;
case 4:
if (ISGRAPH (*indd))
{
epure (pvoie->finf.zip, 8);
scan = pvoie->finf.zip;
while (*scan)
{
if (*scan == ' ')
*scan = '-';
++scan;
}
change = 1;
}
break;
default:
fbb_error (ERR_NIVEAU, "SAISIE-INFO", pvoie->niv3);
break;
}
if (*pvoie->finf.prenom == '\0')
{
texte (T_MBL + 9);
ch_niv3 (1);
}
else if (*pvoie->finf.ville == '\0')
{
texte (T_NOM + 8);
ch_niv3 (2);
}
else if (*pvoie->finf.home == '\0')
{
texte (T_MBL + 53);
ch_niv3 (3);
}
else if (*pvoie->finf.zip == '\0')
{
texte (T_MBL + 54);
ch_niv3 (4);
}
else
{
if (change)
{
if (pvoie->ncur)
{
ecrit_coord (pvoie->ncur->coord, &pvoie->finf);
user_wp (&pvoie->finf);
}
texte (T_QST + 2);
}
finentete ();
ptr = pvoie->sta.indicatif.call;
if (pvoie->sniv1 == N_CONF)
{
pvoie->niv1 = pvoie->sniv1;
pvoie->niv2 = pvoie->sniv2;
pvoie->niv3 = pvoie->sniv3;
pvoie->conf = 1;
}
else
{
maj_niv (N_MBL, 0, 0);
prompt (pvoie->finf.flags, pvoie->niv1);
}
}
}
/*
* MENUS - PREMIER NIVEAU NOMENCLATURE
*/
static void menu_nomenclature (void)
{
int error = 0;
char com[80];
limite_commande ();
sup_ln (indd);
while (*indd && (!ISGRAPH (*indd)))
indd++;
strn_cpy (70, com, indd);
switch (toupper (*indd))
{
case 'N':
maj_niv (5, 1, 0);
modif_nomenc ();
break;
case 'R':
maj_niv (5, 3, 0);
incindd ();
rech_nomenc ();
break;
case 'I':
maj_niv (5, 4, 0);
incindd ();
liste_indic ();
break;
case 'B':
maj_niv (N_MENU, 0, 0);
sortie ();
break;
case 'F':
maj_niv (0, 1, 0);
incindd ();
choix ();
break;
case '\0':
prompt (pvoie->finf.flags, pvoie->niv1);
break;
default:
if (!defaut ())
error = 1;
break;
}
if (error)
{
cmd_err (indd);
}
}
void nomenclature (void)
{
switch (pvoie->niv2)
{
case 0:
menu_nomenclature ();
break;
case 1:
modif_nomenc ();
break;
case 3:
rech_nomenc ();
break;
case 4:
liste_indic ();
break;
case 5:
saisie_infos ();
break;
default:
fbb_error (ERR_NIVEAU, "NOMENC", pvoie->niv2);
break;
}
}
fbb-7.0.11/src/exec_pg.c 0000664 0001750 0001750 00000033134 13747776030 011643 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
#include
/*
* Execution de programmes pour l'utilisateur
*
*/
static void dir_pg (void);
static void pg_commande (void);
static void load_pg (void);
static int nbpg = 0;
#ifdef __linux__
#undef open
#include
#include
#include
#include
cmdlist *tete_cmd = NULL;
static int pty_open (int *pty, struct winsize *winsize)
{
int pid;
int i;
char line[20];
int c;
int tty, devtty;
for (c = 'p'; c <= 's'; c++)
{
for (i = 0; i < 16; i++)
{
sprintf (line, "/dev/pty%c%x", c, i);
*pty = open (line, O_RDWR | O_NOCTTY);
if (*pty >= 0)
break;
}
if (*pty >= 0)
break;
}
if (*pty < 0)
{
fprintf (stderr, "Out of pty\n");
return -1;
}
ioctl (*pty, TIOCEXCL, NULL);
if ((pid = fork ()) != 0)
return pid;
/* child */
close (*pty);
signal (SIGHUP, SIG_DFL);
line[5] = 't';
tty = open (line, O_RDWR);
if (tty < 0)
{
fprintf (stderr, "Cannot open slave side\n");
close (*pty);
return -1;
}
if (chown (line, getuid (), getgid ()) != 0)
perror ("pty_open() chown error");
if (chmod (line, 0600) != 0)
perror ("pty_open() chmod error");
setsid (); /* will break terminal affiliation */
ioctl (tty, TIOCSCTTY, (char *) 0);
if (setuid (getuid ()) < 0 || setgroups(0, NULL) < 0 ||
setgid (getgid ()) < 0)
{
perror ("cannot set UID/GID");
exit (1);
}
devtty = open ("/dev/tty", O_RDWR);
if (devtty < 0)
{
perror ("cannot open /dev/tty");
exit (1);
}
ioctl (devtty, TIOCSWINSZ, winsize);
close (tty);
dup2 (devtty, 0);
dup2 (devtty, 1);
dup2 (devtty, 2);
return 0;
}
int is_cmd (int voie)
{
struct timeval to;
fd_set fds_read;
if (svoie[voie]->niv1 == N_MBL && svoie[voie]->niv2 == 20 && svoie[voie]->niv3 > 0)
{
FD_ZERO (&fds_read);
FD_SET (svoie[voie]->niv3, &fds_read);
to.tv_sec = 0;
to.tv_usec = 0;
return (select (svoie[voie]->niv3 + 1, &fds_read, NULL, NULL, &to) > 0);
}
return 0;
}
void exec_cmd (cmdlist * cptr)
{
if (pvoie->niv3 == 0)
{
int pid, ac;
struct winsize win =
{24, 80, 0, 0};
char *av[20];
if (cptr == NULL)
return;
/* Create the child process */
pid = pty_open (&pvoie->niv3, &win);
if (pid == 0)
{
/* child */
struct termios termios;
char *line;
memset ((char *) &termios, 0, sizeof (termios));
ioctl (0, TIOCSCTTY, (char *) 0);
termios.c_iflag = ICRNL | IXOFF;
termios.c_oflag = OPOST | ONLCR;
termios.c_cflag = CS8 | CREAD /*| CLOCAL */ ;
termios.c_lflag = ISIG | ICANON;
termios.c_cc[VINTR] = 127;
termios.c_cc[VQUIT] = 28;
termios.c_cc[VERASE] = 8;
termios.c_cc[VKILL] = 24;
termios.c_cc[VEOF] = 4;
cfsetispeed (&termios, B38400);
cfsetospeed (&termios, B38400);
tcsetattr (0, TCSANOW, &termios);
/* Transform the command line to list of arguments */
sup_ln (indd);
while (*indd && (!isspace (*indd)))
++indd;
line = calloc (1, strlen (cptr->action) + strlen (indd) + 2);
strcpy (line, cptr->action);
strcat (line, indd);
ac = 0;
av[ac] = strtok (line, " \t\n\r");
while (av[ac])
av[++ac] = strtok (NULL, " \t\n");
/*
envc = 0;
envp[envc] = (char *) malloc (30);
sprintf (envp[envc++], "AXCALL=%s", call);
envp[envc] = (char *) malloc (30);
sprintf (envp[envc++], "PROTOCOL=%s", protocol);
envp[envc] = (char *) malloc (30);
sprintf (envp[envc++], "TERM=linux");
envp[envc] = NULL;
*/
execvp (av[0], av);
/* should never go there */
exit (1);
}
}
else
{
/* read/write the child process */
if (*indd)
write (pvoie->niv3, indd, strlen (indd));
if (is_cmd (voiecur))
{
char buf[250];
int cnt;
cnt = read (pvoie->niv3, buf, sizeof (buf));
if (cnt <= 0)
{
/* End of connection */
close (pvoie->niv3);
pvoie->niv3 = 0;
retour_mbl ();
return;
}
out (buf, cnt);
}
}
}
#endif
void exec_pg (void)
{
int n_sauve;
int ret;
char s[256];
char *ptr = NULL;
FILE *fptr;
if (pvoie->niv3 == 0)
{
/* if ... incindd(); */
teste_espace ();
sup_ln (indd);
if (*indd)
{
ptr = pvoie->appendf;
while (ISGRAPH (*indd))
*ptr++ = *indd++;
*ptr = '\0';
if (!tst_point (pvoie->appendf))
{
retour_mbl ();
return;
}
while_space ();
}
else
{
dir_pg ();
retour_mbl ();
return;
}
}
indd[80] = '\0';
if (pvoie->ncur->coord != 0xffff)
{
/* Ecrit le record de l'utilisateur en fichier */
fptr = ouvre_nomenc ();
fseek (fptr, pvoie->ncur->coord * ((long) sizeof (info)), 0);
fwrite ((char *) &(pvoie->finf), (int) sizeof (info), 1, fptr);
ferme (fptr, 18);
}
#ifdef __WINDOWS__
#define PG_BUF 32000
char *ptr = m_alloue (PG_BUF);
if (ptr == NULL)
return;
memset (ptr, '\0', PG_BUF);
#ifdef __WIN32__
sprintf (s, "PG32\\%s %s-%d %d %u %d %s",
pvoie->appendf, pvoie->sta.indicatif.call, pvoie->sta.indicatif.num,
pvoie->niv3, pvoie->finf.flags, pvoie->ncur->coord, indd);
#else
sprintf (s, "PG\\%s %s-%d %d %u %d %s",
pvoie->appendf, pvoie->sta.indicatif.call, pvoie->sta.indicatif.num,
pvoie->niv3, pvoie->finf.flags, pvoie->ncur->coord, indd);
#endif
ret = filter (s, ptr, PG_BUF, NULL, NULL);
ptr[PG_BUF - 1] = '\0';
if (*ptr)
out (ptr, strlen (ptr));
m_libere (ptr, PG_BUF);
#endif
#ifdef __linux__
char deroute[80];
char *pptr = s;
sprintf (deroute, "%sEXECUTE.xxx", MBINDIR);
sprintf (s, "./%s %s-%d %d %u %d %s",
strlwr (pvoie->appendf),
pvoie->sta.indicatif.call, pvoie->sta.indicatif.num,
pvoie->niv3, pvoie->finf.flags, pvoie->ncur->coord, indd);
ret = call_nbdos (&pptr, 1, REPORT_MODE, deroute, PGDIR, NULL);
if (ret != -1)
{
outfich (deroute);
}
unlink (deroute);
#endif
/*
#ifdef __FBBDOS__
sprintf (s, "PG\\%s %s-%d %d %u %d %s",
pvoie->appendf, pvoie->sta.indicatif.call, pvoie->sta.indicatif.num,
pvoie->niv3, pvoie->finf.flags, pvoie->ncur->coord, indd);
ret = send_dos (4, s, NULL);
#endif
*/
if (pvoie->ncur->coord != 0xffff)
{
/* Relit le record de l'utilisateur du fichier */
fptr = ouvre_nomenc ();
fseek (fptr, pvoie->ncur->coord * ((long) sizeof (info)), 0);
fread ((char *) &(pvoie->finf), (int) sizeof (info), 1, fptr);
ferme (fptr, 18);
}
switch (ret)
{
case 0:
init_hold ();
retour_mbl ();
break;
case 1:
++pvoie->niv3;
break;
case 2:
pvoie->deconnect = 6;
break;
case 3:
pg_commande ();
break;
case 4:
n_sauve = ++pvoie->niv3;
init_hold ();
pg_commande ();
maj_niv (N_MBL, 17, n_sauve);
break;
case 5:
break;
case -1:
clear_outbuf (voiecur);
strcpy (varx[0], pvoie->appendf);
texte (T_ERR + 1);
retour_mbl ();
break;
default:
retour_mbl ();
break;
}
}
static void dir_pg (void)
{
int num = 0;
char str[80];
char *ptr;
#ifdef __WINDOWS__
#ifdef __WIN32__
if (findfirst ("PG32\\*.*", &(pvoie->dirblk), FA_DIREC))
#else
if (findfirst ("PG\\*.*", &(pvoie->dirblk), FA_DIREC))
#endif
{
texte (T_DOS + 2);
return;
}
#endif
#ifdef __FBBDOS__
if (findfirst ("PG\\*.*", &(pvoie->dirblk), FA_DIREC))
{
texte (T_DOS + 2);
return;
}
#endif
#ifdef __linux__
{
cmdlist *clist = tete_cmd;
while (clist)
{
if (num == 4)
{
cr ();
num = 0;
}
sprintf (str, "%-10s", clist->cmd);
out (str, 10);
clist = clist->next;
}
if (num != 0)
cr ();
}
num = 0;
sprintf(str, "%s*", PGDIR);
if (findfirst (str, &(pvoie->dirblk), FA_DIREC))
{
texte (T_DOS + 2);
return;
}
#endif
if (*pvoie->dirblk.ff_name == '.')
{
findnext (&(pvoie->dirblk));
if (findnext (&(pvoie->dirblk)))
{
texte (T_DOS + 2);
return;
}
}
while (1)
{
if ((pvoie->dirblk.ff_attrib & FA_DIREC) == 0)
{
if (num == 4)
{
cr ();
num = 0;
}
ptr = strrchr (pvoie->dirblk.ff_name, '.');
if (ptr)
*ptr = '\0';
sprintf (str, "%-10s", pvoie->dirblk.ff_name);
out (str, 10);
++num;
}
if (findnext (&(pvoie->dirblk)))
break;
}
if (num != 0)
cr ();
}
static void pg_commande (void)
{
obuf *optr;
char *ptr, *tptr;
int ncars, nbcars, nocars;
int maxcar = DATABUF;
if ((optr = pvoie->outptr) != NULL)
{
ncars = 0;
tptr = data;
nbcars = optr->nb_car;
nocars = optr->no_car;
ptr = optr->buffer + nocars;
while (1)
{
if (nbcars == nocars)
{
pvoie->outptr = optr->suiv;
m_libere (optr, sizeof (obuf));
pvoie->memoc -= 250;
if ((optr = pvoie->outptr) != NULL)
{
nbcars = optr->nb_car;
nocars = 0;
ptr = optr->buffer;
}
else
{
/* cprintf(" Vide ") ; */
break;
}
}
*tptr++ = *ptr;
++nocars;
if (++ncars == maxcar)
{
optr->no_car = nocars;
break;
}
++ptr;
}
*tptr = '\0';
maj_niv (N_MBL, 0, 0);
in_buf (voiecur, data, strlen (data));
while (pvoie->inbuf.nblig)
traite_voie (voiecur);
}
}
int appel_pg (char *nom)
{
pglist *lptr = tete_pg;
#ifdef __linux__
cmdlist *cptr = tete_cmd;
strupr (nom);
while (cptr)
{
if (strcmp (nom, cptr->cmd) == 0)
{
maj_niv (N_MBL, 20, 0);
--indd;
exec_cmd (cptr);
return (1);
}
cptr = cptr->next;
}
#else
strupr (nom);
#endif
while (lptr)
{
if (strcmp (nom, lptr->nom_pg) == 0)
{
maj_niv (N_MBL, 17, 0);
--indd;
exec_pg ();
return (1);
}
lptr = lptr->suiv;
}
return (0);
}
#ifdef __linux__
static void load_cmd (void)
{
FILE *fptr;
char line[256];
char cmd[256];
char action[256];
cmdlist *cptr;
fptr = fopen (c_disque ("commands.sys"), "r");
if (fptr == NULL)
return;
while (fgets (line, sizeof (line), fptr))
{
int nb = sscanf (line, "%s %[^\n]", cmd, action);
if (nb < 2 || *cmd == '#')
continue;
cptr = malloc (sizeof (cmdlist));
if (cptr == NULL)
return;
strupr (cmd);
n_cpy (sizeof (cptr->cmd) - 1, cptr->cmd, cmd);
cptr->action = strdup (action);
cptr->next = tete_cmd;
tete_cmd = cptr;
++nbpg;
{
char text[80];
sprintf (text, "%d: CMD %s", nbpg, cptr->cmd);
InitText (text);
}
}
fclose (fptr);
}
#endif
static void load_pg (void)
{
char str[80];
char *ptr;
pglist *lptr = tete_pg;
struct ffblk dirblk;
#if defined(__WINDOWS__) || defined(__FBBDOS__)
#ifdef __WIN32__
if (findfirst ("PG32\\*.*", &dirblk, FA_DIREC))
#else
if (findfirst ("PG\\*.*", &dirblk, FA_DIREC))
#endif
{
return;
}
#endif
#if defined(__linux__)
sprintf(str, "%s*", PGDIR);
if (findfirst (str, &dirblk, FA_DIREC))
{
return;
}
#endif
if (*pvoie->dirblk.ff_name == '.')
{
findnext (&dirblk);
if (findnext (&dirblk))
{
return;
}
}
ptr = strchr (dirblk.ff_name, '.');
if (ptr)
*ptr = '\0';
if ((dirblk.ff_attrib & FA_DIREC) == 0)
{
if (lptr)
{
lptr->suiv = (pglist *) m_alloue (sizeof (pglist));
lptr = lptr->suiv;
}
else
{
tete_pg = lptr = (pglist *) m_alloue (sizeof (pglist));
}
lptr->suiv = NULL;
strn_cpy (8, lptr->nom_pg, dirblk.ff_name);
#if defined(__WINDOWS__) || defined(__linux__)
++nbpg;
{
char text[80];
sprintf (text, "%d: PG %s", nbpg, lptr->nom_pg);
InitText (text);
}
#endif
}
while (findnext (&dirblk) == 0)
{
ptr = strchr (dirblk.ff_name, '.');
if (ptr)
*ptr = '\0';
if ((dirblk.ff_attrib & FA_DIREC) == 0)
{
if (lptr)
{
lptr->suiv = (pglist *) m_alloue (sizeof (pglist));
lptr = lptr->suiv;
}
else
{
tete_pg = lptr = (pglist *) m_alloue (sizeof (pglist));
}
lptr->suiv = NULL;
strn_cpy (8, lptr->nom_pg, dirblk.ff_name);
#if defined(__WINDOWS__) || defined(__linux__)
++nbpg;
{
char text[80];
sprintf (text, "%d: PG %s", nbpg, lptr->nom_pg);
InitText (text);
}
#endif
}
}
#ifdef __linux__
/* Loads the commands of system/commands.sys */
load_cmd ();
#endif
}
void end_pg (void)
{
pglist *lptr;
#ifdef __linux__
cmdlist *cptr;
int voie;
for (voie = 0; voie < NBVOIES; voie++)
{
/* Close open ttys */
if (svoie[voie]->niv1 == N_MBL && svoie[voie]->niv2 == 20 && svoie[voie]->niv3 > 0)
{
printf ("Closing tty %d\n", svoie[voie]->niv3);
close (svoie[voie]->niv3);
}
}
while (tete_cmd)
{
cptr = tete_cmd;
tete_cmd = cptr->next;
m_libere (cptr->action, strlen (cptr->action) + 1);
m_libere (cptr, sizeof (cmdlist));
}
#endif
while (tete_pg)
{
lptr = tete_pg;
tete_pg = tete_pg->suiv;
m_libere (lptr, sizeof (pglist));
}
}
void affich_pg (int tp)
{
#ifdef __linux__
load_pg ();
#endif
#ifdef __WINDOWS__
load_pg ();
#endif
#ifdef __FBBDOS__
fen *fen_ptr;
pglist *lptr;
int size, nb_pg = 0;
load_pg ();
lptr = tete_pg;
while (lptr)
{
++nb_pg;
lptr = lptr->suiv;
}
if (nb_pg == 0)
return;
size = (nb_pg > 19 * 7) ? 19 : 1 + nb_pg / 7;
lptr = tete_pg;
deb_io ();
nb_pg = 0;
fen_ptr = open_win (10, 2, 76, 4 + size, INIT, "PG");
while (lptr)
{
cprintf ("%-8s ", lptr->nom_pg);
lptr = lptr->suiv;
}
attend_caractere (tp);
close_win (fen_ptr);
fin_io ();
#endif
}
fbb-7.0.11/src/balise.c 0000664 0001750 0001750 00000033711 13747770424 011472 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
/*
* BALISE.C Gestion de la balise
*
*/
#include
#define INT14 0x14
#define INT7F 0x7f
typedef struct typ_ddes
{
char indic[8];
long numero;
int port;
struct typ_ddes *suiv;
}
Ddes;
static Beacon *tete_beacon[NBPORT];
static long current_bcl[NBPORT]; /* Message BCL en cours */
static Ddes *t_ddes[NBPORT];
static char *broadcast_bloc (int);
static char *broadcast_line (long);
static char *via (char *);
static void broadcast_port (int, char *);
static void mode_binaire (int);
static void send_broadcast (int, char *, int);
static void set_beacon (char *, Beacon *);
static void set_bcall (char *, indicat *);
static void free_beacon (int port)
{
Beacon *ptemp;
Beacon *pb = tete_beacon[port];
while (pb)
{
ptemp = pb;
pb = pb->next;
m_libere (ptemp, sizeof (Beacon));
}
tete_beacon[port] = NULL;
}
void end_beacon (void)
{
int port;
for (port = 0; port < NBPORT; port++)
free_beacon (port);
}
static void add_beacon (int port, char *texte)
{
Beacon *pb = tete_beacon[port];
if (pb)
{
while (pb->next)
{
pb = pb->next;
}
pb->next = (Beacon *) m_alloue (sizeof (Beacon));
pb = pb->next;
}
else
{
pb = tete_beacon[port] = (Beacon *) m_alloue (sizeof (Beacon));
}
set_beacon (texte, pb);
pb->next = NULL;
}
static void set_bcall (char *callsign, indicat * call_str)
{
int i = 0;
char *ptr = call_str->call;
df ("set_bcall", 4);
call_str->num = 0;
if (callsign == NULL)
{
*ptr = '\0';
ff ();
return;
}
strupr (callsign);
while ((*callsign) && (!isalnum (*callsign)))
++callsign;
while (isalnum (*callsign))
if (i++ < 6)
*ptr++ = *callsign++;
*ptr = '\0';
while ((*callsign) && (!isdigit (*callsign)))
++callsign;
i = 0;
while (isdigit (*callsign))
{
i *= 10;
i += (*callsign++ - '0');
}
if ((i >= 0) && (i <= 15))
call_str->num = i;
ff ();
}
static void set_beacon (char *path, Beacon * beacon)
{
int i = 0;
char *ptr;
beacon->nb_digi = 0;
ptr = strtok (path, " ,\r\n");
set_bcall (ptr, &beacon->desti);
ptr = strtok (NULL, " ,\r\n");
if (ptr)
{
strupr (ptr);
if (((strlen (ptr) == 1) && (*ptr == 'V')) ||
((strlen (ptr) == 3) && (strcmp (ptr, "VIA") == 0)))
{
ptr = strtok (NULL, " ,\r\n");
}
}
for (i = 0; i < 8; i++)
{
if (ptr)
++beacon->nb_digi;
set_bcall (ptr, &beacon->digi[i]);
ptr = strtok (NULL, " ,\r\n");
}
}
static void aff_ui (int port, char *line)
{
int nbcar;
nbcar = strlen (line);
put_ui (line, W_CNST, nbcar);
}
void dde_synchro (char *indic, long num, int port)
{
Ddes *ptemp;
char line[80];
sprintf (line, "[%d] Broadcast SYNC #%ld asked fm %s", port, num, indic);
aff_ui (port, line);
if (p_port[port].moport & 0x20)
{
if (t_ddes[port])
{
ptemp = t_ddes[port];
while (ptemp->suiv)
ptemp = ptemp->suiv;
ptemp->suiv = (Ddes *) m_alloue (sizeof (Ddes));
ptemp = ptemp->suiv;
}
else
{
ptemp = t_ddes[port] = (Ddes *) m_alloue (sizeof (Ddes));
}
ptemp->suiv = NULL;
strn_cpy (6, ptemp->indic, indic);
ptemp->numero = num;
ptemp->port = port;
}
else
{
sprintf (line, "[%d] Port %d not allowed for unproto lists !", port, port);
aff_ui (port, line);
}
}
void send_balise (int port)
{
static int first = 1;
FILE *fptr;
char *ptr;
char sbuffer[600];
int c, var, nb, pos = 0;
int maxcar;
int debut = 1;
Beacon *pb;
df ("send_balise", 1);
aff_etat ('B');
if (first)
{
first = 0;
for (nb = 0; nb < NBPORT; nb++)
{
t_ddes[nb] = NULL;
tete_beacon[nb] = NULL;
current_bcl[nb] = nomess;
}
}
free_beacon (port);
if (p_port[port].pvalid)
{
sprintf (sbuffer, "BEACON%d.SYS", port);
if ((fptr = fopen (c_disque (sbuffer), "rt")) != NULL)
{
maxcar = p_port[port].beacon_paclen;
if (maxcar == 0)
maxcar = 128;
nb = 0;
vlang = 0; /* langue primaire */
var = FALSE;
ptr = NULL;
while (1)
{
if (var)
{
if (*ptr)
{
sbuffer[nb] = *ptr++;
nb++;
}
else
var = FALSE;
}
else
{
if ((c = fgetc (fptr)) == EOF)
break;
if ((pos == 0) && (c == '%'))
{
if (fscanf (fptr, "%d", &t_balise[port])) {
t_balise[port] *= 60;
fgetc (fptr);
} else {
perror ("send_balise() error reading port");
}
}
else if ((pos == 0) && (c == '!'))
{
fgets (sbuffer, 80, fptr);
add_beacon (port, sbuffer);
nb = 0;
}
else
{
if (tete_beacon[port] == NULL)
{
strcpy(sbuffer, "MAIL");
add_beacon (port, sbuffer);
}
if ((debut) && (p_port[port].moport & 0x20))
{
if (current_bcl[port] == nomess)
{
sprintf (sbuffer, "%-6ld !!\r", nomess);
send_broadcast (port, sbuffer, strlen (sbuffer));
}
debut = 0;
}
++pos;
if (c == '$')
{
if ((c = fgetc (fptr)) == EOF)
break;
ptr = variable (c);
var = TRUE;
}
else if (c == '%')
{
if ((c = fgetc (fptr)) == EOF)
break;
ptr = alt_variable (c);
var = TRUE;
}
else
{
if (c == '\n')
{
sbuffer[nb] = '\r';
++nb;
pos = 0;
}
else if (c != '\r')
{
sbuffer[nb] = c;
nb++;
}
}
}
}
if (nb == maxcar)
{
for (pb = tete_beacon[port]; pb ; pb = pb->next)
{
snd_drv (port, UNPROTO, sbuffer, nb, pb);
}
nb = 0;
}
}
ferme (fptr, 12);
if (nb)
{
for (pb = tete_beacon[port]; pb ; pb = pb->next)
{
snd_drv (port, UNPROTO, sbuffer, nb, pb);
}
}
}
}
ff ();
}
static char *via (char *bbsv)
{
int lg = 0;
static char buffer[40];
char *ptr = buffer;
if (*bbsv)
{
*ptr++ = '@';
++lg;
}
while (isalnum (*bbsv))
{
*ptr++ = *bbsv++;
if (++lg == 7)
break;
}
while (lg++ < 7)
*ptr++ = ' ';
*ptr = '\0';
return (buffer);
}
static void send_broadcast (int port, char *buffer, int len)
{
indicat sav_beacon;
Beacon *pb = tete_beacon[port];
if ((len == 0) || (*buffer == '\0'))
return;
while (pb)
{
sav_beacon = pb->desti;
strcpy (pb->desti.call, "FBB");
pb->desti.num = 0;
snd_drv (port, UNPROTO, buffer, len, pb);
pb->desti = sav_beacon;
pb = pb->next;
}
}
void broadcast_port (int port, char *chaine)
{
int len;
int lt;
char bloc[256];
char tampon[90];
char *optr;
int maxcar = p_port[port].pk_t;
if (maxcar == 0)
maxcar = 128;
*bloc = '\0';
len = 0;
while (*chaine)
{
optr = tampon;
lt = 0;
for (;;)
{
*optr++ = *chaine;
++lt;
if ((*chaine++ == '\r') || (lt == 89))
{
break;
}
}
*optr = '\0';
if ((len + lt) > maxcar)
{
if (*bloc)
{
send_broadcast (port, bloc, len);
*bloc = '\0';
len = 0;
}
else
{
send_broadcast (port, tampon, lt);
*tampon = '\0';
lt = 0;
}
}
strcat (bloc, tampon);
len += lt;
}
send_broadcast (port, bloc, len);
}
static char *broadcast_line (long numero)
{
static char sbuffer[128];
char titre[40];
bullist bull;
bullist *sav;
int ok = 0;
sav = ptmes;
ptmes = •
if (ch_record (NULL, numero, '\0'))
{
ok = 1;
}
if (ok && (strcmp (ptmes->desti, "KILL") == 0))
ok = 0;
if (ok && (strcmp (ptmes->desti, "WP") == 0))
ok = 0;
if (ok && (ptmes->type == 'A') && (!ack_unproto))
ok = 0;
if (ok && (ptmes->type != 'B'))
{
if ((*ptmes->bbsv == '\0') && (!priv_unproto))
ok = 0;
}
if (ok && (ptmes->type != 'B'))
{
if ((*ptmes->bbsv) && (!via_unproto))
ok = 0;
}
if (ok && ((ptmes->status == 'A') || (ptmes->status == 'K')))
ok = 0;
if (ok)
{
if ((mute_unproto) && (ptmes->type == 'P'))
strcpy (titre, "***");
else
n_cpy (34, titre, ptmes->titre);
sprintf (sbuffer,
"%-6ld %c %6ld %-6s%s %-6s %s %s\r",
ptmes->numero, ptmes->type,
(ptmes->taille > 1000000L) ? 999999L : ptmes->taille, ptmes->desti,
via (ptmes->bbsv), ptmes->exped, date_mbl (ptmes->date), titre);
}
else
sprintf (sbuffer, "%-6ld #\r", numero);
ptmes = sav;
return (sbuffer);
}
static char *broadcast_bloc (int port)
{
FILE *fptr;
info frec;
int back_mess = 0;
int offset;
long dde_bcl;
char *ptr;
Ddes *ptemp;
ind_noeud *exp;
bloc_mess *bptr;
mess_noeud *mptr;
unsigned num_indic;
bullist bul;
static char beacon_buffer[256];
char line[80];
*beacon_buffer = '\0';
*line = '\0';
while (t_ddes[port])
{
/* Demande de synchro */
dde_bcl = t_ddes[port]->numero;
if ((nomess - dde_bcl) > nb_unproto)
dde_bcl = nomess - nb_unproto;
else
back_mess = 1;
/* cherche les prives eventuels et envoie le premier ... */
exp = insnoeud (t_ddes[port]->indic, &num_indic);
if (exp->coord != 0xffff)
{
fptr = ouvre_nomenc ();
fseek (fptr, (long) exp->coord * sizeof (frec), 0);
fread (&frec, sizeof (info), 1, fptr);
ferme (fptr, 79);
if (!UNP (frec.flags))
{
sprintf (beacon_buffer, "%-6ld / %s\r", current_bcl[port], t_ddes[port]->indic);
sprintf (line, "[%d] U Flag not set for %s, stopped !", port, t_ddes[port]->indic);
aff_ui (port, line);
back_mess = 1;
}
else
{
if (nomess <= dde_bcl)
{
sprintf (beacon_buffer, "%-6ld !!\r", nomess);
sprintf (line, "[%d] %s asked %ld, end of list %ld !", port, t_ddes[port]->indic, dde_bcl, nomess);
aff_ui (port, line);
back_mess = 1;
}
else
{
ouvre_dir ();
bptr = tete_dir;
offset = 0;
if (dde_bcl < current_bcl[port])
{
current_bcl[port] = dde_bcl;
}
sprintf (line, "[%d] %s allowed, resync to %ld", port, t_ddes[port]->indic, current_bcl[port]);
aff_ui (port, line);
while (bptr)
{
mptr = &(bptr->st_mess[offset]);
if ((mptr->noenr) && (mptr->no_indic == num_indic))
{
read_dir (mptr->noenr, &bul);
/* if ((bul.status != 'K') && (bul.status != 'H') && (bul.status != 'A')) { */
if (bul.status == 'N')
{
if ((bul.numero > t_ddes[port]->numero) && (bul.numero <= current_bcl[port]))
{
sprintf (line, "[%d] %s unread private %ld", port, t_ddes[port]->indic, bul.numero - 1);
aff_ui (port, line);
sprintf (beacon_buffer, "%-6ld ! %s\r", bul.numero - 1, t_ddes[port]->indic);
ptr = broadcast_line (bul.numero);
strcat (beacon_buffer, ptr);
back_mess = 1;
break;
}
}
}
if (++offset == T_BLOC_MESS)
{
bptr = bptr->suiv;
offset = 0;
}
}
ferme_dir ();
}
}
}
else
{
sprintf (line, "[%d] Unknown callsign %s, stopped !", port, t_ddes[port]->indic);
aff_ui (port, line);
sprintf (beacon_buffer, "%-6ld / %s\r", current_bcl[port], t_ddes[port]->indic);
back_mess = 1;
}
if (back_mess == 0)
{
sprintf (line, "[%d] %s, end of list %ld", port, t_ddes[port]->indic, current_bcl[port]);
aff_ui (port, line);
sprintf (beacon_buffer, "%-6ld ! %s\r", current_bcl[port], t_ddes[port]->indic);
}
ptemp = t_ddes[port];
t_ddes[port] = t_ddes[port]->suiv;
m_libere (ptemp, sizeof (Ddes));
}
if (back_mess == 0)
{
for (;;)
{
if (current_bcl[port] == nomess)
break;
ptr = broadcast_line (current_bcl[port] + 1);
if ((strlen (beacon_buffer) + strlen (ptr)) > 250)
{
break;
}
strcat (beacon_buffer, ptr);
++current_bcl[port];
}
}
return (beacon_buffer);
}
void broadcast_list (void)
{
int port;
char *ptr;
df ("broadcast_list", 0);
for (port = 1; port < NBPORT; port++)
{
if ((p_port[port].pvalid) && (p_port[port].moport & 0x20))
{
if ((t_ddes[port] == NULL) && (current_bcl[port] == nomess))
continue;
ptr = broadcast_bloc (port);
if (*ptr == '\0')
{
ff ();
return;
}
broadcast_port (port, ptr);
}
}
ff ();
}
static void mode_binaire (int voie)
{
if (svoie[voie]->binary == 0)
{
clear_inbuf (voie);
time_yapp[voie] = -1;
set_binary(voie, 1);
}
}
void send_bin_message (void)
{
switch (pvoie->niv3)
{
case 5:
env_message ();
break;
case 6:
if (bin_message (pvoie->t_read) == 0)
{
ch_niv3 (5);
env_message ();
}
break;
}
if (pvoie->niv3 == 2)
{
retour_mbl ();
pvoie->temp1 = -2;
}
}
void send_binary_mess (void)
{
long no;
long seek_offset;
int nb = 0;
bullist *pbul;
rd_list *ptemp = NULL;
init_fb_mess (voiecur);
incindd ();
pvoie->fbb = 1;
if ((no = lit_chiffre (0)) != 0)
{
seek_offset = 0L;
if (*indd == '!')
{
++indd;
pvoie->fbb = 2;
seek_offset = lit_chiffre (0);
}
if (ptemp)
{
ptemp->suite = (rd_list *) m_alloue (sizeof (rd_list));
ptemp = ptemp->suite;
}
else
{
pvoie->t_read = ptemp = (rd_list *) m_alloue (sizeof (rd_list));
}
ptemp->pmess = &(pvoie->fb_mess[nb]);
ptemp->suite = NULL;
ptemp->nmess = no;
ptemp->verb = 1;
if ((pbul = ch_record (NULL, no, 'Y')) != NULL)
{
if (droit_ok (pbul, 1))
{
pvoie->fb_mess[nb] = *pbul;
pvoie->fb_mess[nb].taille = seek_offset;
}
else
{
ptemp->verb = 0;
}
}
else
{
ptemp->verb = 0;
}
}
mode_binaire (voiecur);
pvoie->enrcur = 0L;
maj_niv (N_RBIN, 0, 5);
send_bin_message ();
pvoie->temp1 = -2; /* Demande la suppression des messages apres envoi */
}
fbb-7.0.11/src/fwdovl2.c 0000664 0001750 0001750 00000060425 13613525174 011610 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
/*
* MODULE FORWARDING OVERLAY 2
*/
#include
#include
static int tst_line (char *, int);
static int tst_var (char *);
char *idnt_fwd (void)
{
static char buffer[25];
char *ptr = buffer;
*ptr++ = '[';
*ptr++ = 'F';
*ptr++ = 'B';
*ptr++ = 'B';
*ptr++ = '-';
*ptr++ = '0' + PACKAGE_VERSION_MAJOR;
*ptr++ = '.';
*ptr++ = '0' + PACKAGE_VERSION_MINOR;
*ptr++ = '.';
//*ptr++ = '0' + PACKAGE_VERSION_MICRO;
if (PACKAGE_VERSION_MICRO < 10) {
*ptr++ = '0' + PACKAGE_VERSION_MICRO;
} else if (PACKAGE_VERSION_MICRO < 100) {
*ptr++ = '0' + (PACKAGE_VERSION_MICRO / 10);
*ptr++ = '0' + (PACKAGE_VERSION_MICRO % 10);
}
*ptr++ = '-';
*ptr++ = 'A';
if (pvoie->prot_fwd & FWD_FBB)
{
if (pvoie->prot_fwd & FWD_BIN)
{
*ptr++ = 'B';
if (pvoie->prot_fwd & FWD_BIN1)
*ptr++ = '1';
}
*ptr++ = 'F';
}
*ptr++ = 'H';
*ptr++ = 'M';
if (pvoie->mbl_ext)
*ptr++ = 'R';
if (pvoie->prot_fwd & FWD_XPRO)
*ptr++ = 'X';
*ptr++ = '$';
*ptr++ = ']';
*ptr++ = '\r';
*ptr++ = '\0';
return (buffer);
}
#ifdef __linux__
int nbcan_linux (void)
{
int nbcan = 0;
int i;
for (i = 1; i < NBPORT; i++)
if (S_LINUX (i))
nbcan += p_port[i].nb_voies;
return (nbcan);
}
#endif
int nbcan_hst (void)
{
int nbcan = 0;
int i;
for (i = 1; i < NBPORT; i++)
if ((HST (i)) && (p_port[i].ccanal != 0))
nbcan += p_port[i].nb_voies;
return (nbcan);
}
int nbcan_drsi (void)
{
int nbcan = 0;
int i;
for (i = 1; i < NBPORT; i++)
if (DRSI (i))
nbcan += p_port[i].nb_voies;
return (nbcan);
}
int nbcan_bpq (void)
{
int nbcan = 0;
int i;
for (i = 1; i < NBPORT; i++)
if (BPQ (i))
nbcan += p_port[i].nb_voies;
return (nbcan);
}
int ch_voie (int port, int canal)
{
/*
* Cherche une voie libre sur un port.
* Commence par la derniere voie du port
*
* Si canal != 0, essaye d'allouer le canal specifie.
*/
int i, j;
if (port == 0)
{
if (svoie[INEXPORT]->sta.connect)
return (-1);
return (1);
}
if (save_fic)
return (-1);
if (p_port[port].pvalid == 0)
return (-1);
if (DRSI (port))
{
if (port_free (port) == 0)
return (-1);
if (canal)
{
for (j = 1; j < NBVOIES; j++)
{
if ((svoie[j]->affport.canal == canal) &&
(DRSI (no_port (j))) &&
(!svoie[j]->sta.connect) &&
(!voie_forward (j)))
{
svoie[j]->affport.port = port;
for (i = 0; i < 8; i++)
*(svoie[j]->sta.relais[i].call) = '\0';
init_fb_mess (j);
return (j);
}
}
}
else
{
for (i = nbcan_drsi (); i > 0; i--)
{
for (j = 1; j < NBVOIES; j++)
{
if ((svoie[j]->affport.canal == i) &&
(DRSI (no_port (j))) &&
(!svoie[j]->sta.connect) &&
(!voie_forward (j)))
{
svoie[j]->affport.port = port;
for (i = 0; i < 8; i++)
*(svoie[j]->sta.relais[i].call) = '\0';
init_fb_mess (j);
return (j);
}
}
}
}
}
else if (BPQ (port))
{
if (port_free (port) == 0)
return (-1);
if (canal)
{
for (j = 1; j < NBVOIES; j++)
{
if ((svoie[j]->affport.canal == canal) &&
(BPQ (no_port (j))) &&
(!svoie[j]->sta.connect) &&
(!voie_forward (j)))
{
svoie[j]->affport.port = port;
for (i = 0; i < 8; i++)
*(svoie[j]->sta.relais[i].call) = '\0';
init_fb_mess (j);
return (j);
}
}
}
else
{
for (i = nbcan_bpq (); i > 0; i--)
{
for (j = 1; j < NBVOIES; j++)
{
if ((svoie[j]->affport.canal == i) &&
(BPQ (no_port (j))) &&
(!svoie[j]->sta.connect) &&
(!voie_forward (j)))
{
svoie[j]->affport.port = port;
for (i = 0; i < 8; i++)
*(svoie[j]->sta.relais[i].call) = '\0';
init_fb_mess (j);
return (j);
}
}
}
}
}
#ifdef __linux__
else if (S_LINUX (port))
{
if (port_free (port) == 0)
return (-1);
if (canal)
{
for (j = 1; j < NBVOIES; j++)
{
if ((svoie[j]->affport.canal == canal) &&
(S_LINUX (no_port (j))) &&
(!svoie[j]->sta.connect) &&
(!voie_forward (j)))
{
svoie[j]->affport.port = port;
for (i = 0; i < 8; i++)
*(svoie[j]->sta.relais[i].call) = '\0';
init_fb_mess (j);
return (j);
}
}
}
else
{
for (i = nbcan_linux (); i > 0; i--)
{
for (j = 1; j < NBVOIES; j++)
{
if ((svoie[j]->affport.canal == i) &&
(S_LINUX (no_port (j))) &&
(!svoie[j]->sta.connect) &&
(!voie_forward (j)))
{
svoie[j]->affport.port = port;
for (i = 0; i < 8; i++)
*(svoie[j]->sta.relais[i].call) = '\0';
init_fb_mess (j);
return (j);
}
}
}
}
}
#endif
if (HST (port))
{
int com = p_port[port].ccom;
if (port_free (port) == 0)
return (-1);
if (p_port[port].ccanal == 0)
{
/* Port Pactor. Cherche la voie correspondante */
for (j = 1; j < NBVOIES; j++)
{
if ((svoie[j]->affport.canal == PACTOR_CH) &&
(HST (no_port (j))) &&
(p_port[no_port (j)].ccom == com) &&
(!svoie[j]->sta.connect) &&
(!voie_forward (j)))
{
svoie[j]->affport.port = port;
for (i = 0; i < 8; i++)
*(svoie[j]->sta.relais[i].call) = '\0';
init_fb_mess (j);
return (j);
}
}
return (-1);
}
if (canal)
{
for (j = 1; j < NBVOIES; j++)
{
if ((svoie[j]->affport.canal == canal) &&
(HST (no_port (j))) &&
(p_port[no_port (j)].ccom == com) &&
(!svoie[j]->sta.connect) &&
(!voie_forward (j)))
{
svoie[j]->affport.port = port;
for (i = 0; i < 8; i++)
*(svoie[j]->sta.relais[i].call) = '\0';
init_fb_mess (j);
return (j);
}
}
}
else
{
for (i = nbcan_hst (); i > 0; i--)
{
for (j = 1; j < NBVOIES; j++)
{
if ((svoie[j]->affport.canal == i) &&
(HST (no_port (j))) &&
(p_port[no_port (j)].ccom == com) &&
(!svoie[j]->sta.connect) &&
(!voie_forward (j)))
{
svoie[j]->affport.port = port;
for (i = 0; i < 8; i++)
*(svoie[j]->sta.relais[i].call) = '\0';
init_fb_mess (j);
return (j);
}
}
}
}
}
else
{
if (canal)
{
for (j = 1; j < NBVOIES; j++)
{
if ((svoie[j]->affport.port == port) &&
(svoie[j]->affport.canal == canal) &&
(!svoie[j]->sta.connect) && (!voie_forward (j)))
{
for (i = 0; i < 8; i++)
*(svoie[j]->sta.relais[i].call) = '\0';
init_fb_mess (j);
return (j);
}
}
}
else
{
for (i = p_port[port].nb_voies; i > 0; i--)
{
for (j = 1; j < NBVOIES; j++)
{
if ((svoie[j]->affport.port == port) &&
(svoie[j]->affport.canal == i) &&
(!svoie[j]->sta.connect) && (!voie_forward (j)))
{
for (i = 0; i < 8; i++)
*(svoie[j]->sta.relais[i].call) = '\0';
init_fb_mess (j);
return (j);
}
}
}
}
}
return (-1);
}
static char *check_call (char *ptr)
{
char *scan = ptr;
while (*scan > ' ')
++scan;
if (*scan == '\0')
scan = ptr;
else
{
while ((*scan) && (isspace (*scan)))
++scan;
if (isgraph(*scan) && !isalnum(*scan)) /* Pactor - ! ou % */
++scan;
if ((isdigit (*scan)) && (!isalnum (*(scan + 1))))
{
++scan;
while ((*scan) && (!isalnum (*scan)))
++scan;
}
}
return (scan);
}
int connect_fwd (int voie, Forward * pfwd)
{
int nb;
stat_fwd = 0;
nb = connect_station (voie, 0, pfwd->con_lig[0]);
svoie[voie]->niv1 = N_FORW;
svoie[voie]->niv2 = 2;
svoie[voie]->niv3 = 0;
/* fprintf(stderr, "connect_fwd : voie %d niv1 %d niv2 %d niv3 %d\n", voie, svoie[voie]->niv1, svoie[voie]->niv2, svoie[voie]->niv3);*/
if ((DEBUG) || (!p_port[no_port (voie)].pvalid))
{
pfwd->forward = -1;
}
return (nb);
}
int connect_station (int voie, int echo, char *ptr)
{
int port = no_port (voie);
char buffer[256];
char *scan = check_call (ptr);
int nb = 0, sav_voie = voiecur;
svoie[voie]->debut = time (NULL);
svoie[voie]->finf.lang = langue[0]->numlang;
if ((DEBUG) || (!p_port[no_port (voie)].pvalid))
return (0);
selvoie (voie);
svoie[voie]->sta.indicatif.num = extind (scan, svoie[voie]->sta.indicatif.call);
/* fprintf(stderr, "connect_station : %s-%d\n", svoie[voie]->sta.indicatif.call, svoie[voie]->sta.indicatif.num);*/
strcpy (buffer, ptr);
deb_io ();
switch (p_port[port].typort)
{
case TYP_DED: /* DED */
if (DRSI (port))
{
if (strchr (ptr, ':') == NULL)
{
while (ISGRAPH (*ptr))
++ptr;
while (isspace (*ptr))
++ptr;
sprintf (buffer, "C %d:%s", p_port[port].ccanal, ptr);
}
}
tnc_commande (voie, buffer, SNDCMD);
break;
case TYP_PK: /* PK232 */
buffer[1] = 'O';
tnc_commande (voie, buffer, SNDCMD);
break;
case TYP_HST: /* PTC-II */
case TYP_FLX:
tnc_commande (voie, buffer, SNDCMD);
break;
#ifndef __linux__
case TYP_MOD: /* MODEM */
md_no_echo (voie);
svoie[voie]->sta.stat = 1;
strtok (buffer, " ");
strtok (NULL, " ");
scan = strtok (NULL, " ");
if (scan)
md_send (no_port (voie), var_txt (scan));
svoie[voie]->maj_ok = 0;
break;
#endif
case TYP_KAM: /* KAM */
kam_commande (voie, buffer);
break;
#ifdef __linux__
case TYP_SCK: /* AX25 */
tnc_commande (voie, buffer, SNDCMD);
break;
#else
case TYP_BPQ: /* BPQ */
command = 1;
sta_drv (voie, CMDE, (void *) &command);
break;
#endif
#ifdef __linux__
case TYP_TCP: /* TELNET */
case TYP_ETH: /* ETHER-LINK */
tnc_commande (voie, buffer, SNDCMD);
break;
#endif
#ifdef __WINDOWS__
case TYP_ETH: /* ETHER-LINK */
{
tnc_commande (voie, buffer, SNDCMD);
}
break;
case TYP_TCP: /* TELNET */
{
tnc_commande (voie, buffer, SNDCMD);
}
break;
case TYP_AGW: /* AX25 */
tnc_commande (voie, buffer, SNDCMD);
break;
#endif
}
fin_io ();
/* Au cas ou pas de SID ... */
svoie[voie]->fbb = 0;
svoie[voie]->mbl_ext = 0;
svoie[voie]->sta.connect = 1;
svoie[voie]->maj_ok = 0;
selvoie (sav_voie);
if ((echo) && (nb))
outln (buffer, nb);
status (voie);
return (nb);
}
static int tst_line (char *ptr, int val)
{
int nb;
while ((*ptr) && (!isdigit (*ptr)))
ptr++;
while (*ptr)
{
nb = 0;
while ((*ptr) && (!ISGRAPH (*ptr)))
ptr++;
if (*ptr == '*')
return (FALSE);
while (isdigit (*ptr))
{
nb *= 10;
nb += (*ptr++ - '0');
}
while ((*ptr) && (!ISGRAPH (*ptr)))
ptr++;
if (isalpha (*ptr))
{
if (val == nb)
return (TRUE);
else
return (FALSE);
}
switch (*ptr++)
{
case ',':
if (val == nb)
return (TRUE);
break;
case '-':
if (val >= nb)
{
nb = 0;
while ((*ptr) && (!ISGRAPH (*ptr)))
ptr++;
while (isdigit (*ptr))
{
nb *= 10;
nb += (*ptr++ - '0');
}
if (val <= nb)
return (TRUE);
}
break;
case '\n':
case 0:
if (val == nb)
return (TRUE);
return (FALSE);
default:
#ifdef ENGLISH
cprintf ("Error in time list \r\n");
#else
cprintf ("Erreur liste horaire\r\n");
#endif
return (FALSE);
}
}
return (FALSE);
}
void swap_port (char *port_name)
{
int port;
int trouve = 0;
strupr (port_name);
for (port = 1; port < NBPORT; port++)
{
if (p_port[port].pvalid)
{
if (strcmp (port_name, p_port[port].freq) == 0)
{
port_name[0] = port + '@';
trouve = 1;
break;
}
}
}
if ((!trouve) && (port_name[1] != '\0'))
{
if (!operationnel)
{
/* Erreur, le port n'existe pas ... */
char buf[80];
sprintf (buf,
"Error : port \"%s\" in forward file does not exist",
port_name);
win_message (5, buf);
}
port_name[0] = 'A';
}
port_name[1] = '\0';
}
int tst_fwd (char *ptr, int nobbs, long h_time, int port, int *nb_choix, int reverse, int cur_port)
{
char temp[40];
int i, choix;
int val;
while (isspace (*ptr))
++ptr;
switch (val = toupper (*ptr))
{
case 'C': /* Choix links */
if (nobbs)
{
while ((*ptr) && (!isdigit (*ptr)))
ptr++;
choix = (int) *ptr - '0';
if ((nb_choix) && (choix > *nb_choix))
{
*nb_choix = choix;
}
if (choix == get_link (nobbs))
{
return (val);
}
}
return (FALSE);
case 'D': /* Choix jour */
++ptr;
return ((tst_line (ptr, jour (h_time))) ? val : FALSE);
case 'N': /* Choix No du jour */
++ptr;
return ((tst_line (ptr, nojour (h_time))) ? val : FALSE);
case 'F': /* Choix port libre */
while (ISGRAPH (*ptr))
++ptr;
while (isspace (*ptr))
++ptr;
if (*ptr)
{
strn_cpy (39, temp, ptr);
swap_port (temp);
if (find (strupr (temp)))
{
for (i = 0; i < NBVOIES; i++)
{
if ((svoie[i]->sta.connect) && (strcmp (svoie[i]->sta.indicatif.call, temp) == 0))
{
return (FALSE);
}
}
}
else
{
port = *temp - '@';
for (i = 0; i < NBVOIES; i++)
{
if ((svoie[i]->sta.connect) && (no_port (i) == port))
{
return (FALSE);
}
}
}
}
else
{
for (i = 0; i < NBVOIES; i++)
{
if ((svoie[i]->sta.connect) && (no_port (i) == port))
{
return (FALSE);
}
}
}
return (val);
case 'G': /* Choix heure GMT */
++ptr;
return ((tst_line (ptr, gmt_heure (h_time))) ? val : FALSE);
case 'H': /* Choix heure locale */
++ptr;
return ((tst_line (ptr, heure (h_time))) ? val : FALSE);
case 'M': /* Forward manuel */
++ptr;
return ((reverse) ? val : FALSE);
case 'P':
while (ISGRAPH (*ptr))
++ptr;
while (isspace (*ptr))
++ptr;
i = -2;
if (*ptr)
{
strn_cpy (39, temp, ptr);
swap_port (temp);
i = *temp - '@';
}
return ((i == cur_port) ? val : FALSE);
case 'V': /* Test variable environnement */
++ptr;
return ((tst_var (ptr)) ? val : FALSE);
default:
return ((tst_line (ptr, heure (h_time))) ? val : FALSE);
}
}
static int tst_var (char *chaine)
{
char var[80];
char val[80];
char *env;
sscanf (chaine, "%s %s", var, val);
env = getenv (var);
if (env == NULL)
return (0);
return (strcmp (env, val) == 0);
}
void analyse_idnt (char *chaine)
{
char *ptr;
int fin = 0;
unsigned lprot_fwd = FWD_MBL;
sup_ln (chaine);
pvoie->sid = 1;
pvoie->fbb = 1;
pvoie->mbl_ext = 0;
pvoie->mode |= F_FOR;
if (pvoie->timout == time_n)
pvoie->timout = time_b;
ptr = strrchr (chaine, '-');
if (ptr)
++ptr;
else
ptr = chaine + 1;
while (!fin)
{
switch (*ptr++)
{
case '\0':
case ']':
case '-':
fin = 1;
break;
case 'H':
pvoie->mode |= F_HIE;
break;
case 'A':
pvoie->mode |= F_ACQ;
break;
case 'B':
lprot_fwd |= FWD_BIN;
if (isdigit (*ptr))
{
if ((*ptr >= '1') && (bin_fwd == 2))
{
pvoie->fbb = 2;
lprot_fwd |= FWD_BIN1;
}
++ptr;
}
break;
case 'C':
if (pvoie->clock)
pvoie->clock = 2;
break;
case 'F':
lprot_fwd |= FWD_FBB;
break;
case 'M':
pvoie->mode |= F_MID;
break;
case 'R':
pvoie->mbl_ext = 1;
break;
case 'X':
lprot_fwd |= FWD_XPRO;
break;
case '$':
pvoie->mode |= F_BID;
break;
default:
break;
}
}
if (lprot_fwd & FWD_FBB)
{
pvoie->mode |= F_FBB; /* Protocole FBB valide */
if (lprot_fwd & FWD_BIN)
{
pvoie->mode |= F_BIN; /* Transfert binaire valide */
}
}
lprot_fwd &= pvoie->prot_fwd;
if ((lprot_fwd & FWD_XPRO) && (std_header & 512))
{
/* XFwd prioritaire */
pvoie->mode &= (~(F_FBB | F_BIN));
lprot_fwd &= (~FWD_FBB);
}
if ((lprot_fwd & FWD_BIN) == 0)
{
lprot_fwd &= (~FWD_BIN1);
}
if ((lprot_fwd & FWD_FBB) == 0)
{
lprot_fwd &= (~(FWD_BIN | FWD_BIN1));
}
pvoie->prot_fwd = lprot_fwd;
aff_forward ();
}
int att_prompt (void)
{
char *ptr = indd;
int modex = FALSE;
int error = 0;
if (*indd == '!')
{
incindd ();
new_om = -1;
accept_cnx ();
return (FALSE);
}
if ((pvoie->nb_prompt == 0) && (*indd == '['))
modex = TRUE;
if (*indd == '*')
error++;
while (nb_trait--)
{
if ((error) && (*ptr == '*'))
{
if (++error == 4)
pvoie->deconnect = 4;
break;
}
else
error = 0;
if (*ptr == '\r')
{
if ((pvoie->nb_prompt == 0) && (*(ptr - 1) == ']') && (modex))
{
*ptr = '\0';
analyse_idnt (indd);
/* Choisit le protocole en fonction des options */
/* si les deux protocoles FBB et XFWD sont OK */
if ((pvoie->prot_fwd & FWD_FBB) && (pvoie->prot_fwd & FWD_XPRO))
{
if (std_header & 512)
{
/* XFwd prioritaire */
pvoie->prot_fwd &= (~(FWD_FBB | FWD_BIN | FWD_BIN1));
}
else
{
/* FBB prioritaire */
pvoie->prot_fwd &= (~FWD_XPRO);
}
}
}
else if (*(ptr - 1) == '>')
{
if (pvoie->nb_prompt > 0)
--pvoie->nb_prompt;
else
{
if (pvoie->sid == 0)
{
/* Pas de SID recu -> ni fbb, ni xfwd */
pvoie->prot_fwd = 0;
}
return TRUE;
}
}
else
modex = FALSE;
}
++ptr;
}
return FALSE;
}
static int is_duplicate_forward (int nobbs)
{
Forward *pfwd;
int port;
int nb_bbs = 0;
for (port = 0; port < NBPORT; port++)
{
if (p_port[port].pvalid)
{
pfwd = p_port[port].listfwd;
while (pfwd)
{
if (pfwd->no_bbs == nobbs)
++nb_bbs;
pfwd = pfwd->suite;
}
}
}
return (nb_bbs > 1);
}
int mess_suiv (int voie)
/*
* Y a-t-il encore un message ?
* Si oui, typ_mess, n_mess, enrdeb et enrcur sont mis a jour. retour TRUE .
* Si non, retour FALSE .
*/
{
long no;
df ("mess_suiv", 1);
if (save_fic)
{
++pvoie->sta.ack;
svoie[voie]->deconnect = 6;
ff ();
return (0);
}
if (svoie[voie]->bbsfwd == 0)
{
ff ();
return (0);
}
/* teste si un forward est deja en cours -> pas de proposition */
if (is_duplicate_forward (svoie[voie]->bbsfwd))
{
ff ();
return (0);
}
while ((no = msg_fwd_suiv ((int) svoie[voie]->bbsfwd,
svoie[voie]->maxfwd, svoie[voie]->oldfwd, svoie[voie]->typfwd, voie)) != 0L)
{
if (ch_record (ptmes, no, '\0'))
{
if ((ptmes->status == 'N') ||
(ptmes->status == 'Y') ||
(ptmes->status == '$'))
{
ff ();
return (TRUE);
}
}
/* Le message n'existe plus : supression de la liste */
clear_fwd (no);
}
ff ();
return (FALSE);
}
void program_tnc (int voie, char *ptr)
{
int nb;
char buffer[300];
switch (p_port[no_port (voie)].typort)
{
case TYP_DED: /* DED */
case TYP_HST: /* PTC */
case TYP_FLX:
if (*ptr == 'B')
{
++ptr;
while ((*ptr) && (!ISGRAPH (*ptr)))
++ptr;
nb = atoi (ptr);
if ((nb >= 30) && (nb <= 250))
svoie[voie]->paclen = nb;
else
cprintf ("INVALID VALUE: %s\r\n", ptr);
}
else
{
if ((!DEBUG) && (p_port[no_port (voie)].pvalid))
{
strcpy (buffer, ptr);
tnc_commande (voie, buffer, ECHOCMD);
if (*buffer)
{
cprintf ("%s\r\n", buffer);
}
}
}
break;
case TYP_PK: /* PK232 */
if ((*ptr == 'B') && (!isgraph (*(ptr + 1))))
{
++ptr;
while ((*ptr) && (!ISGRAPH (*ptr)))
++ptr;
nb = atoi (ptr);
if ((nb >= 10) && (nb <= 250))
svoie[voie]->paclen = nb;
else
cprintf ("INVALID VALUE: %s\r\n", ptr);
}
else
{
if ((!DEBUG) && (p_port[no_port (voie)].pvalid))
tnc_commande (voie, ptr, ECHOCMD);
}
break;
case TYP_KAM: /* KAM */
if ((*ptr == 'B') && (!isgraph (*(ptr + 1))))
{
++ptr;
while ((*ptr) && (!ISGRAPH (*ptr)))
++ptr;
nb = atoi (ptr);
if ((nb >= 30) && (nb <= 250))
svoie[voie]->paclen = nb;
else
cprintf ("INVALID VALUE: %s\r\n", ptr);
}
else
{
if ((!DEBUG) && (p_port[no_port (voie)].pvalid))
kam_commande (voie, ptr);
}
break;
case TYP_BPQ: /* BPQ */
if ((*ptr == 'B') && (!isgraph (*(ptr + 1))))
{
++ptr;
while ((*ptr) && (!ISGRAPH (*ptr)))
++ptr;
nb = atoi (ptr);
if ((nb == 0) || ((nb >= 30) && (nb <= 250)))
svoie[voie]->paclen = nb;
else
cprintf ("INVALID VALUE: %s\r\n", ptr);
}
break;
#ifdef __WINDOWS__
case TYP_AGW: /* AGW */
if (*ptr == 'B')
{
++ptr;
while ((*ptr) && (!ISGRAPH (*ptr)))
++ptr;
nb = atoi (ptr);
if ((nb >= 30) && (nb <= 250))
svoie[voie]->paclen = nb;
else
cprintf ("INVALID VALUE: %s\r\n", ptr);
}
else
{
if ((!DEBUG) && (p_port[no_port (voie)].pvalid))
{
strcpy (buffer, ptr);
tnc_commande (voie, buffer, ECHOCMD);
if (*buffer)
{
cprintf ("%s\r\n", buffer);
}
}
}
break;
#endif
}
}
void program_fwd (int affiche, int fwd, typ_pfwd ** ptnc, int voie)
{
char *ptr;
typ_pfwd *pcurr, *ptemp;
#ifdef __linux__
typ_pfwd *prev;
int done;
int nbdos;
char *list[25]; /* 25 taches DOS max */
#endif
#ifdef __WINDOWS__
typ_pfwd *prev;
int done;
int nbdos;
char *list[25]; /* 25 taches DOS max */
#endif
#ifdef __FBBDOS__
char s[80];
fen *fen_ptr;
#endif
pcurr = *ptnc;
if (pcurr == NULL)
return;
#if defined(__WINDOWS__)
prev = NULL;
while (pcurr)
{
ptr = pcurr->chaine;
if (voie)
{
done = 0;
if (pcurr->type)
{ /* Commande DOS */
if (strncmpi (ptr, "PTCTRX", 6) == 0)
{
ptctrx (no_port (voie), ptr);
done = 1;
}
/* DLL Actions */
else if (call_dll (ptr, NO_REPORT_MODE, NULL, 0, NULL) != -1)
{
done = 1;
}
}
else
{ /* Programm TNC */
if (fwd)
program_tnc (voie, ptr);
done = 1;
}
}
else
done = 1;
if (done)
{
/* Enleve la cammande de la liste */
ptemp = pcurr;
if (prev)
{
prev->suiv = pcurr->suiv;
pcurr = pcurr->suiv;
}
else
{
/* Tete de liste ... */
*ptnc = pcurr = pcurr->suiv;
}
m_libere (ptemp, sizeof (typ_pfwd));
}
else
{
prev = pcurr;
pcurr = pcurr->suiv;
}
}
/* Runs the DOS actions */
pcurr = *ptnc;
if (pcurr == NULL)
return;
nbdos = 0;
while (pcurr)
{
ptr = pcurr->chaine;
if (voie)
{
if (pcurr->type)
{
if (nbdos < 25)
list[nbdos++] = pcurr->chaine;
}
}
pcurr = pcurr->suiv;
}
if (nbdos)
call_nbdos (list, nbdos, NO_REPORT_MODE, NULL, TOOLDIR, NULL);
/* Frees the list */
while (pcurr)
{
ptemp = pcurr;
pcurr = pcurr->suiv;
m_libere (ptemp, sizeof (typ_pfwd));
}
#endif
#if defined(__linux__)
prev = NULL;
while (pcurr)
{
ptr = pcurr->chaine;
if (voie)
{
done = 0;
if (pcurr->type)
{ /* Commande DOS */
if (strncmpi (ptr, "PTCTRX", 6) == 0)
{
ptctrx (no_port (voie), ptr);
done = 1;
}
}
else
{ /* Programm TNC */
if (fwd)
program_tnc (voie, ptr);
done = 1;
}
}
else
done = 1;
if (done)
{
/* Enleve la cammande de la liste */
ptemp = pcurr;
if (prev)
{
prev->suiv = pcurr->suiv;
pcurr = pcurr->suiv;
}
else
{
/* Tete de liste ... */
*ptnc = pcurr = pcurr->suiv;
}
m_libere (ptemp, sizeof (typ_pfwd));
}
else
{
prev = pcurr;
pcurr = pcurr->suiv;
}
}
/* Runs the DOS actions */
pcurr = *ptnc;
if (pcurr == NULL)
return;
nbdos = 0;
while (pcurr)
{
ptr = pcurr->chaine;
if (voie)
{
if (pcurr->type)
{
if (nbdos < 25)
list[nbdos++] = pcurr->chaine;
}
}
pcurr = pcurr->suiv;
}
if (nbdos)
call_nbdos (list, nbdos, NO_REPORT_MODE, NULL, TOOLDIR, NULL);
/* Frees the list */
while (pcurr)
{
ptemp = pcurr;
pcurr = pcurr->suiv;
m_libere (ptemp, sizeof (typ_pfwd));
}
#endif
#ifdef __FBBDOS__
if (affiche)
{
sprintf (s, "TNC Prog. Ch %d", voie);
fen_ptr = open_win (50, 8, 73, 21, INIT, s);
}
while (pcurr)
{
ptr = pcurr->chaine;
if (voie)
{
if (pcurr->type)
{ /* Commande DOS */
if (strncmpi (ptr, "PTCTRX", 6) == 0)
{
ptctrx (no_port (voie), ptr);
}
else
{
send_dos (pcurr->type, ptr, NULL);
}
}
else
{ /* Programm TNC */
if (fwd)
{
if (affiche)
cprintf ("%s\r\n", ptr);
program_tnc (voie, ptr);
}
}
}
ptemp = pcurr;
pcurr = pcurr->suiv;
m_libere (ptemp, sizeof (typ_pfwd));
}
#endif
*ptnc = NULL;
#ifdef __FBBDOS__
if (affiche)
{
sleep_ (1);
close_win (fen_ptr);
}
#endif
}
fbb-7.0.11/src/mblutil.c 0000664 0001750 0001750 00000054700 13613525371 011673 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
/*
* MBLUTIL.C
*
*/
#include
#include
#ifdef TRACE
static int fd_trace = -1;
open_trace ()
{
fd_trace = open ("TRACE.MON", O_WRONLY | O_APPEND | O_CREAT | O_TEXT, S_IREAD | S_IWRITE);
}
close_trace ()
{
if (fd_trace != -1)
close (fd_trace);
}
static trace (char *chaine, int lg, int date)
{
char *ptr = chaine;
int i;
long temps;
struct tm *sdate;
char cdate[20];
static char ret = '\n';
if (fd_trace == -1)
return;
for (i = 0; i < lg; i++)
{
if (*ptr == '\r')
*ptr = '\n';
++ptr;
}
write (fd_trace, chaine, lg);
if (date)
{
temps = time (NULL);
sdate = localtime (&temps);
sprintf (cdate, " (%02d:%02d:%02d)", sdate->tm_hour, sdate->tm_min, sdate->tm_sec);
write (fd_trace, cdate, 11);
}
}
#endif
void force_deconnexion (int voie, int mode)
{
df ("force_deconnexion", 2);
if ((p_port[no_port (voie)].typort == TYP_HST) && (P_TOR (voie)))
{
/* WinDebug("Immediate disconnect request\r\n"); */
tnc_commande (voie, "!DD", SNDCMD);
dec_voie (voie);
}
else
{
deconnexion (voie, mode);
deconnexion (voie, mode);
}
ff ();
}
void debug_mode (void)
{
if (debug_on)
{
if (!debug_fptr)
debug_fptr = fopen ("DEBUG.BUG", "at");
}
else
{
if (debug_fptr)
fclose (debug_fptr);
debug_fptr = NULL;
}
}
int virt_canal (int nocan)
{
int canal;
if (nocan > 1)
canal = nocan - 1;
else if (nocan == 1)
canal = 99;
else
canal = 0;
return (canal);
}
void aff_chaine (int color, int xpos, int ypos, char *chaine)
{
#ifdef __FBBDOS__
struct text_info sav_fen;
df ("aff_chaine", 5);
deb_io ();
gettext_info (&sav_fen);
fen_haut (color);
curoff ();
gotoxy (xpos, ypos);
cputs (chaine);
puttext_info (&sav_fen);
fin_io ();
ff ();
#endif
}
int nbport (void)
{
int nbp = 0, port;
df ("nbport", 0);
for (port = 1; port < NBPORT; port++)
if (p_port[port].pvalid)
nbp++;
ff ();
return (nbp);
}
int read_only (void)
{
if (pvoie->read_only)
{
outln ("*** Error : read-only mode", 26);
/* texte(T_ERR + 0); */
return (1);
}
return (0);
}
char *lf_to_cr (char *texte)
{
char *ptr = texte;
char *optr = texte;
while (*ptr)
{
if ((*ptr == '\r') && (*(ptr + 1) == '\n'))
{
++ptr;
}
else
{
if (*ptr == '\n')
*optr++ = '\r';
else
*optr++ = *ptr;
++ptr;
}
}
*optr = '\0';
return (texte);
}
void while_space (void)
{
while (isspace (*indd))
++indd;
}
int strmatch (char *chaine, char *masque)
{
while (1)
{
switch (*masque)
{
case '\0':
return (toupper (*masque) == toupper (*chaine));
case '&':
if ((*chaine == '\0') || (*chaine == '.'))
return (1);
break;
case '?':
if (!isalnum (*chaine))
return (0);
break;
case '#':
if ((*chaine != '#') && (!isdigit (*chaine)))
return (0);
break;
case '@':
if (!isalpha (*chaine))
return (0);
break;
case '=':
if (!ISGRAPH (*chaine))
return (0);
break;
case '*':
while (*++masque == '*')
;
if (*masque == '\0')
return (1);
while (!strmatch (chaine, masque))
if (*++chaine == '\0')
return (0);
break;
default:
if ((toupper (*chaine)) != (toupper (*masque)))
return (0);
break;
}
++chaine;
++masque;
}
}
void ch_niv3 (int niveau)
{
maj_niv (pvoie->niv1, pvoie->niv2, niveau);
}
void ch_niv2 (int niveau)
{
maj_niv (pvoie->niv1, niveau, 0);
}
void ch_niv1 (int niveau)
{
maj_niv (niveau, 0, 0);
}
int droits (unsigned int droit)
{
if (voiecur == CONSOLE)
return (1);
return (droit & pvoie->droits);
}
void ch_bit (ind_noeud * noeud, info * frec, unsigned bit, char rep)
{
FILE *fptr;
int c = toupper (rep);
if ((c != Oui) && (c != Non) && (c != '\0'))
return;
if (pvoie->read_only)
return;
fptr = ouvre_nomenc ();
fseek (fptr, (long) noeud->coord * sizeof (info), 0);
fread (frec, sizeof (info), 1, fptr);
rep = toupper (rep);
if (c == Oui)
{
frec->flags |= bit;
}
else if (c == Non)
{
frec->flags &= (~bit);
}
else if (c == '\0')
{
if (frec->flags & bit)
{
frec->flags &= (~bit);
}
else
{
frec->flags |= bit;
}
}
if (noeud->coord == 0xffff)
dump_core ();
fseek (fptr, (long) noeud->coord * sizeof (info), 0);
fwrite (frec, sizeof (info), 1, fptr);
ferme (fptr, 42);
noeud->val = (uchar) (EXC (frec->flags) == 0);
}
void cmd_err (char *ptri)
{
int i = 0;
char *ptr = varx[0];
while (ISGRAPH (*ptri))
{
if (++i == 40)
break;
else
*ptr++ = *ptri++;
}
*ptr = '\0';
texte (T_ERR + 1);
*varx[0] = '\0';
if ((FOR (pvoie->mode)) || (++pvoie->nb_err == MAX_ERR))
pvoie->deconnect = 6;
else
retour_menu (pvoie->niv1);
}
void strn_cpy (int longueur, char *dest, char *orig)
{
while (longueur--)
{
if (!ISPRINT (*orig))
break;
*dest++ = toupper (*orig);
++orig;
}
*dest = '\0';
}
void n_cpy (int longueur, char *dest, char *orig)
{
while (longueur--)
{
if (*orig == '\0')
break;
*dest++ = *orig++;
}
*dest = '\0';
}
void init_recliste (int voie)
{
tlist *ptlist = &svoie[voie]->recliste;
ptlist->l = FALSE;
ptlist->type = '\0';
ptlist->status = '\0';
ptlist->route = '\0';
*ptlist->exp = '\0';
*ptlist->dest = '\0';
*ptlist->bbs = '\0';
*ptlist->find = '\0';
ptlist->debut = 0L;
ptlist->fin = 0x7fffffffL;
ptlist->avant = 0L;
ptlist->apres = 0x7fffffffL;
ptlist->last = 0x7fffffffL;
if (*svoie[voie]->finf.filtre)
strn_cpy (6, ptlist->dest, svoie[voie]->finf.filtre);
}
int droit_ok (bullist * lbul, int mode)
{
/*
* mode 1 : consultation (lecture)
* mode 2 : suppression (ecriture)
* mode 3 : archivage
* mode 4 : idem mode 2 mais autorise tuer le message "Non lu"
*/
int kill_new = 0;
if (mode == 4)
{
mode = 2;
kill_new = 1;
}
if (mode == 3)
{
if (lbul->status == 'A')
return (0);
else
return (1);
}
if (lbul->status == 'K')
{
if (mode == 2)
return (0);
}
if (droits (SUPMES))
return (1);
if ((mode == 1) && (droits (CONSMES) || PRV (pvoie->finf.flags)))
if ((strcmp (lbul->desti, "KILL") != 0) && (lbul->status != 'H'))
return (1);
if (lbul->status == 'H')
{
if ((SYS (pvoie->finf.flags)) || indcmp (lbul->exped, pvoie->sta.indicatif.call))
return (1);
else
return (0);
}
if (strcmp (lbul->desti, "WP") == 0)
return (0);
switch (lbul->type)
{
case 'A':
case 'P':
switch (mode)
{
case 2:
if (indcmp (lbul->desti, pvoie->sta.indicatif.call))
{
if ((kill_new) || (lbul->status != 'N'))
{
return (1);
}
}
if (indcmp (lbul->exped, pvoie->sta.indicatif.call))
return (1);
break;
case 1:
if ((indcmp (lbul->desti, pvoie->sta.indicatif.call)) ||
(indcmp (lbul->exped, pvoie->sta.indicatif.call)))
return (1);
break;
}
break;
case ' ':
case 'B':
if (mode == 2)
{
if ((indcmp (lbul->exped, pvoie->sta.indicatif.call)) ||
(indcmp (lbul->desti, pvoie->sta.indicatif.call)))
return (1);
}
else if (lbul->status == 'A')
return (0);
else if (strcmp (lbul->desti, "KILL") != 0)
return (1);
break;
case 'T':
if (lbul->status == 'A')
return (0);
else
return (1);
default:
return (0);
}
return (0);
}
void retour_mbl (void)
{
libere_tread (voiecur);
libere_tlist (voiecur);
pvoie->mbl = 1;
pvoie->private_dir = 0;
set_bs (voiecur, TRUE);
retour_menu (N_MBL);
}
int teste_rep (char *chaine)
{
if (iscntrl (*chaine))
return (0);
if (*chaine == ' ')
return (1);
else
{
texte (T_ERR + 2);
return (0);
}
}
long lit_chiffre (int ajuste)
{
long chif;
char *ptr;
if (*indd == '\0')
return (0L);
teste_espace ();
if (isdigit (*indd))
{
ptr = indd;
while ((*indd) && (isdigit (*indd)))
++indd;
chif = atol (ptr);
if ((ajuste) && (chif < ECART))
chif += (1000L * (long) pvoie->finf.on_base);
return (chif);
}
else if (*indd)
{
if (*indd == '#')
{
++indd;
return (ptmes->numero);
}
else
texte (T_ERR + 3);
}
return (0L);
}
int is_espace (char *ptr)
{
int espace = (*ptr == ' ');
while ((*ptr) && (*ptr == ' '))
++ptr;
if (ISPRINT (*ptr))
return (espace);
else
return (1);
}
int teste_espace (void)
{
int ok = 0;
if (*indd)
{
if (*indd == ' ')
ok = 1;
while ((*indd) && (!ISGRAPH (*indd)))
++indd;
}
return (ok);
}
long supp_header (FILE * fptr, int ok)
{
int c, first = 1, nb = 0, call = 0;
char ligne[90];
char *ptr = ligne;
int flag = FALSE;
long record = 0L;
short int postexte = 0;
record = ftell (fptr);
while ((c = fgetc (fptr)) != EOF)
{
if ((flag) && (c == '\n'))
{
record = ftell (fptr);
postexte = 0;
call = 0;
flag = FALSE;
}
else
{
switch (call)
{
case 0:
break;
case 1:
if (isalnum (c))
{
*ptr++ = c;
nb++;
call = 2;
}
break;
case 2:
if (isalnum (c))
{
*ptr++ = c;
nb++;
}
else
{
*ptr++ = '!';
nb++;
call = 0;
if (nb >= 65)
{
outln (ligne, nb);
nb = 0;
ptr = ligne;
first = 2;
}
}
break;
}
if (postexte == 0)
{
if (c != 'R') /*return(record) */
break;
else
flag = TRUE;
}
if ((postexte == 1) && (flag) && (c != ':')) /*return(record) */
break;
++postexte;
}
if ((ok) && (flag) && (c == '@'))
{
if (first)
{
if (first == 1)
out ("Path: !", 7);
else
out (" !", 7);
first = 0;
}
call = 1;
}
}
if (nb)
outln (ligne, nb);
/* return(ftell(fptr)) ; */
return (record);
}
bullist *ch_record (bullist * list, long no, char status)
{
mess_noeud *lptr;
static bullist ltemp;
bullist *lbul;
ind_noeud *noeud;
char temp = '\0';
int ok = 0;
int kill_new = 0;
int no_type = 0;
if (status == 'Z')
{
no_type = 1;
status = 'A';
}
if (status & 0x80)
{
kill_new = 1;
status &= 0x7f;
}
if (list)
lbul = list;
else
lbul = <emp;
lbul->numero = no;
if ((lptr = findmess (no)) != NULL)
{
ouvre_dir ();
read_dir (lptr->noenr, lbul);
if (lbul->type)
{
if (status == 'Y')
{
++lbul->nblu;
temp = lbul->status;
}
if ((status) && (status != lbul->status))
{
switch (status)
{
case 'Y':
if ((lbul->status == 'N') || (lbul->status == '$'))
{
if ((lbul->type == 'P') || (lbul->type == 'A'))
{
if (indcmp (pvoie->sta.indicatif.call, lbul->desti))
{
noeud = cher_noeud (lbul->desti);
--(pvoie->ncur->nbnew);
}
else
break;
}
else
{
if ((lbul->status == '$') ||
(indcmp (pvoie->sta.indicatif.call, lbul->exped)))
break;
}
temp = lbul->status;
lbul->status = status;
}
break;
case 'F':
if (lbul->status == 'K')
break;
if (lbul->status == 'X')
break;
if (lbul->status == 'A')
break;
noeud = cher_noeud (lbul->desti);
if (lbul->status == 'N')
--(noeud->nbnew);
if ((lbul->type == 'P') && (lbul->status == '$'))
--(noeud->nbnew);
chg_mess (0xffff, no);
temp = lbul->status;
lbul->status = status;
break;
case 'A':
lbul->datech = 0L;
case 'K':
if ((!kill_new) && (lbul->datech))
{
if (!droit_ok (lbul, 2))
break;
else if (!droit_ok (lbul, 3))
break;
}
noeud = cher_noeud (lbul->desti);
if ((!kill_new) && (!droits (SUPMES)))
{
if ((indcmp (pvoie->sta.indicatif.call, lbul->desti)))
{
if (lbul->status == 'N')
break;
}
}
if (lbul->status == 'N')
{
if (noeud->nbnew > 0)
--(noeud->nbnew);
}
/*
if (lbul->status == 'H') {
--nb_hold;
}
*/
if ((lbul->status != 'K') && (lbul->status != 'A'))
{
if (noeud->nbmess > 0)
--(noeud->nbmess);
chg_mess (0xffff, no);
}
temp = lbul->status;
lbul->status = status;
break;
case 'H':
if (!droit_ok (lbul, 2))
break;
noeud = cher_noeud (lbul->desti);
if (((lbul->status != 'N') || (lbul->type != 'P')) &&
((lbul->status != '$') || (lbul->type != 'B')))
break;
if (lbul->status == 'N')
{
--(noeud->nbnew);
}
if ((lbul->status != 'K') && (lbul->status != 'A'))
{
--(noeud->nbmess);
/* chg_mess(0xffff, no); */
}
temp = lbul->status;
lbul->status = status;
break;
}
}
if (temp)
{
if (lbul->datech)
lbul->datech = time (NULL);
if (no_type)
lbul->type = '\0';
write_dir (lptr->noenr, lbul);
lbul->status = temp;
aff_msg_cons ();
}
ok = 1;
}
ferme_dir ();
}
*ptmes = *lbul;
if (ok)
return (lbul);
else
return (NULL);
}
int entete_liste (void)
{
return (texte (T_MBL + 36));
}
int indcmp (char *ind1, char *ind2)
{
char *ptr1 = ind1;
char *ptr2 = ind2;
if (*ptr1 != *ptr2)
return (FALSE);
++ptr1;
++ptr2;
if ((!isalnum (*ptr1)) && (!isalnum (*ptr2)))
return (TRUE);
if (*ptr1++ != *ptr2++)
return (FALSE);
while ((isalnum (*ptr1)) || (isalnum (*ptr2)))
{
if (*ptr1++ != *ptr2++)
return (FALSE);
}
return (TRUE);
}
/*
* teste si ind2 est compris dans ind1
* en tenant compte des champs de hierarchie
*
*/
int hiecmp (char *ind1, char *ind2)
{
char str[80];
char *ptr;
strcpy (str, ind1);
for (;;)
{
if (strcmpi (str, ind2) == 0)
return (TRUE);
ptr = strrchr (str, '.');
if (ptr == NULL)
break;
*ptr = '\0';
}
return (FALSE);
}
char *sup_ln (char *buf)
{
int nb = strlen (buf);
if (nb > 0)
{
while (nb--)
{
if (ISGRAPH (buf[nb]))
break;
if (buf[nb])
buf[nb] = '\0';
}
}
return (buf);
}
char *ch_slash (char *chaine)
{
char *ptr = chaine;
while (*ptr)
{
if (*ptr == '/')
*ptr = '\\';
++ptr;
}
return (chaine);
}
char *tot_path (char *nom_fic, char *source)
{
int lg;
char vdisk;
static char temp[256];
*temp = '\0';
/*
char *ptr;
ptr = nom_fic;
while (*ptr)
{
if (islower (*ptr))
*ptr = toupper (*ptr);
++ptr;
}
*/
vdisk = pvoie->vdisk;
if (nom_fic[1] == ':')
{
if (((voiecur == CONSOLE) || (pvoie->kiss == -2)) && (!pvoie->cmd_new))
{
vdisk = nom_fic[0] - 'A';
}
else
{
vdisk = nom_fic[0] - 'A';
if (vdisk == 15)
vdisk = 8;
if (vdisk > 8)
vdisk = 0;
if ((vdisk < 8) && (*PATH[(int)vdisk] == '\0'))
vdisk = 0;
}
nom_fic += 2;
}
if ((pvoie->kiss == -2) || ((droits (ACCESDOS)) && (pvoie->temp1 != N_YAPP) && (!pvoie->cmd_new)))
{
sprintf (temp, "%c:", vdisk + 'A');
#ifdef __linux__
if (*nom_fic != '/')
#else
if (*nom_fic != '\\')
#endif
strcat (temp, source);
}
else
{
if (pvoie->temp1 == N_YAPP)
{
strcpy (temp, YAPPDIR);
}
else
{
if (vdisk == 8)
{
if (pvoie->finf.priv[1] != ':')
sprintf (temp, "%c:%s", 'A' + getdisk (), pvoie->finf.priv);
else
strcpy (temp, pvoie->finf.priv);
}
else
strcpy (temp, PATH[(int)vdisk]);
}
#ifdef __linux__
if (((lg = strlen (temp)) > 1) && (temp[lg - 1] == '/'))
temp[lg - 1] = '\0';
if (*nom_fic != '/')
#else
if (((lg = strlen (temp)) > 1) && (temp[lg - 1] == '\\'))
temp[lg - 1] = '\0';
if (*nom_fic != '\\')
#endif
strcat (temp, source);
}
/* DEBUG F6BVP
printf ("tot_path() temp '%s' source '%s' nom_fic '%s'\n", temp, source, nom_fic);*/
strcat (temp, nom_fic);
strcpy(temp, long_filename(NULL, temp));
vir_path (temp);
return temp;
}
void tester_masque (void)
{
char *t = pvoie->ch_temp;
int cpt = 0;
if (*indd == '\0')
*t++ = '*';
else
{
while (isalnum (*indd))
{
if (cpt++ < 7)
{
*t++ = toupper (*indd);
++indd;
}
else
break;
}
}
*t = '\0';
}
char *comp_bid (char *bid)
{
static char out_bid[BIDCOMP];
char in_bid[BIDLEN];
char *ibid, *obid;
int i, fin = 0;
for (i = 0; i < BIDLEN; i++)
{
if ((!fin) && (*bid))
{
in_bid[i] = (*bid - 32) & 0x3f;
}
else
{
fin = 1;
in_bid[i] = '\0';
}
++bid;
}
ibid = in_bid;
obid = out_bid;
for (i = 0; i < BIDCOMP; i += 3)
{
obid[0] = (ibid[0] << 2) + (ibid[1] >> 4);
obid[1] = (ibid[1] << 4) + (ibid[2] >> 2);
obid[2] = (ibid[2] << 6) + (ibid[3]);
ibid += 4;
obid += 3;
}
return (out_bid);
}
void var_cpy (int novar, char *texte)
{
if ((novar >= 0) && (novar < 10))
n_cpy (80, varx[novar], texte);
}
void fbb_log (int voie, char event, char *texte)
{
if (svoie[voie]->log)
port_log (voie, 1, event, texte);
}
void port_log (int voie, int val, char event, char *texte)
{
int lvoie;
struct tm *sdate;
char *ptr;
long temps = time (NULL);
char com[256], buf[80];
if (comlog)
{
lvoie = (val) ? voie : 0;
sdate = localtime (&temps);
n_cpy (66, buf, sup_ln (texte));
ptr = buf;
while (*ptr)
{ /* Supression des caracteres de controle */
if (iscntrl (*ptr))
*ptr = '_';
++ptr;
}
sprintf (com, "%02d%02d%02d%02d%02d%02d%c%s\r\n",
sdate->tm_mon + 1, sdate->tm_mday, sdate->tm_hour, sdate->tm_min,
sdate->tm_sec, lvoie, event, buf);
if (log_ptr == NULL)
ouvre_log ();
if (log_ptr)
fputs (com, log_ptr);
}
}
/* Table de conversion engendrée mécaniquement par Free «recode» 3.5
pour séquence «IBM850..ISO-8859-1 (réversible)». */
unsigned char const IBM850_ISO_8859_1[256] =
{
0, 1, 2, 3, 4, 5, 6, 7, /* 0 - 7 */
8, 9, 10, 11, 12, 13, 14, 15, /* 8 - 15 */
16, 17, 18, 19, 20, 21, 22, 23, /* 16 - 23 */
24, 25, 26, 27, 28, 29, 30, 31, /* 24 - 31 */
32, 33, 34, 35, 36, 37, 38, 39, /* 32 - 39 */
40, 41, 42, 43, 44, 45, 46, 47, /* 40 - 47 */
48, 49, 50, 51, 52, 53, 54, 55, /* 48 - 55 */
56, 57, 58, 59, 60, 61, 62, 63, /* 56 - 63 */
64, 65, 66, 67, 68, 69, 70, 71, /* 64 - 71 */
72, 73, 74, 75, 76, 77, 78, 79, /* 72 - 79 */
80, 81, 82, 83, 84, 85, 86, 87, /* 80 - 87 */
88, 89, 90, 91, 92, 93, 94, 95, /* 88 - 95 */
96, 97, 98, 99, 100, 101, 102, 103, /* 96 - 103 */
104, 105, 106, 107, 108, 109, 110, 111, /* 104 - 111 */
112, 113, 114, 115, 116, 117, 118, 119, /* 112 - 119 */
120, 121, 122, 123, 124, 125, 126, 127, /* 120 - 127 */
199, 252, 233, 226, 228, 224, 229, 231, /* 128 - 135 */
234, 235, 232, 239, 238, 236, 196, 197, /* 136 - 143 */
201, 230, 198, 244, 246, 242, 251, 249, /* 144 - 151 */
255, 214, 220, 248, 163, 216, 215, 159, /* 152 - 159 */
225, 237, 243, 250, 241, 209, 170, 186, /* 160 - 167 */
191, 174, 172, 189, 188, 161, 171, 187, /* 168 - 175 */
155, 157, 141, 129, 139, 193, 194, 192, /* 176 - 183 */
169, 150, 132, 140, 148, 162, 165, 151, /* 184 - 191 */
156, 145, 147, 128, 142, 143, 227, 195, /* 192 - 199 */
131, 144, 146, 133, 138, 153, 158, 164, /* 200 - 207 */
240, 208, 202, 203, 200, 134, 205, 206, /* 208 - 215 */
207, 137, 130, 136, 154, 166, 204, 152, /* 216 - 223 */
211, 223, 212, 210, 245, 213, 181, 254, /* 224 - 231 */
222, 218, 219, 217, 253, 221, 175, 180, /* 232 - 239 */
173, 177, 149, 190, 182, 167, 247, 184, /* 240 - 247 */
176, 168, 183, 185, 179, 178, 135, 160, /* 248 - 255 */
};
/* Conversion table generated mechanically by Free `recode' 3.5
for sequence ISO-8859-1..IBM850 (reversible). */
unsigned char const ISO_8859_1_IBM850[256] =
{
0, 1, 2, 3, 4, 5, 6, 7, /* 0 - 7 */
8, 9, 10, 11, 12, 13, 14, 15, /* 8 - 15 */
16, 17, 18, 19, 20, 21, 22, 23, /* 16 - 23 */
24, 25, 26, 27, 28, 29, 30, 31, /* 24 - 31 */
32, 33, 34, 35, 36, 37, 38, 39, /* 32 - 39 */
40, 41, 42, 43, 44, 45, 46, 47, /* 40 - 47 */
48, 49, 50, 51, 52, 53, 54, 55, /* 48 - 55 */
56, 57, 58, 59, 60, 61, 62, 63, /* 56 - 63 */
64, 65, 66, 67, 68, 69, 70, 71, /* 64 - 71 */
72, 73, 74, 75, 76, 77, 78, 79, /* 72 - 79 */
80, 81, 82, 83, 84, 85, 86, 87, /* 80 - 87 */
88, 89, 90, 91, 92, 93, 94, 95, /* 88 - 95 */
96, 97, 98, 99, 100, 101, 102, 103, /* 96 - 103 */
104, 105, 106, 107, 108, 109, 110, 111, /* 104 - 111 */
112, 113, 114, 115, 116, 117, 118, 119, /* 112 - 119 */
120, 121, 122, 123, 124, 125, 126, 127, /* 120 - 127 */
195, 179, 218, 200, 186, 203, 213, 254, /* 128 - 135 */
219, 217, 204, 180, 187, 178, 196, 197, /* 136 - 143 */
201, 193, 202, 194, 188, 242, 185, 191, /* 144 - 151 */
223, 205, 220, 176, 192, 177, 206, 159, /* 152 - 159 */
255, 173, 189, 156, 207, 190, 221, 245, /* 160 - 167 */
249, 184, 166, 174, 170, 240, 169, 238, /* 168 - 175 */
248, 241, 253, 252, 239, 230, 244, 250, /* 176 - 183 */
247, 251, 167, 175, 172, 171, 243, 168, /* 184 - 191 */
183, 181, 182, 199, 142, 143, 146, 128, /* 192 - 199 */
212, 144, 210, 211, 222, 214, 215, 216, /* 200 - 207 */
209, 165, 227, 224, 226, 229, 153, 158, /* 208 - 215 */
157, 235, 233, 234, 154, 237, 232, 225, /* 216 - 223 */
133, 160, 131, 198, 132, 134, 145, 135, /* 224 - 231 */
138, 130, 136, 137, 141, 161, 140, 139, /* 232 - 239 */
208, 164, 149, 162, 147, 228, 148, 246, /* 240 - 247 */
155, 151, 163, 150, 129, 236, 231, 152, /* 248 - 255 */
};
uchar *ansi_to_ibm(uchar *buffer, int len)
{
uchar *ptr = buffer;
while (len--)
{
*ptr = ISO_8859_1_IBM850[(int)*ptr];
++ptr;
}
return buffer;
}
uchar *ibm_to_ansi(uchar *buffer, int len)
{
uchar *ptr = buffer;
while (len--)
{
*ptr = IBM850_ISO_8859_1[(int)*ptr];
++ptr;
}
return buffer;
}
#undef fopen
#undef fclose
#undef fprintf
/*
void debuglog(char *fmt,...)
{
time_t temps = time(NULL);
va_list argptr;
FILE *fptr = fopen("/tmp/debug.log", "a+");
if (!fptr)
return;
fprintf (fptr, "\n%s", asctime (localtime (&temps)));
va_start (argptr, fmt);
vfprintf (fptr, fmt, argptr);
va_end (argptr);
fclose(fptr);
}
*/
fbb-7.0.11/src/init_srv.c 0000664 0001750 0001750 00000033235 13614605203 012052 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
#include
#include
#include
static int no_init_error = 1;
void err_init (int lig)
{
no_init_error = 0;
#if defined(__WINDOWS__)
ShowError ("INIT.SRV", "Error line", lig);
fbb_quit (0);
#endif
#if defined(__linux__)
ShowError ("FBB.CONF", "Error line", lig);
fbb_quit (0);
#endif
#ifdef __FBBDOS__
#ifdef ENGLISH
cprintf ("Error file INIT.SRV line %d \r\n\a", lig);
#else
cprintf ("Erreur fichier INIT.SRV ligne %d\r\n\a", lig);
#endif
curon ();
sleep (10);
exit (0);
#endif
}
static char *test_back_slash (char *chaine, int nolig)
{
static char temp[256];
strcpy(temp, chaine);
#ifdef __linux__
if (temp[strlen (temp) - 1] != '/')
strcat(temp, "/");
/* err_init (nolig); */
#else
if (temp[strlen (temp) - 1] != '\\')
err_init (nolig);
#endif
return (temp);
}
void end_admin (void)
{
Msysop *sptr;
while (mess_sysop)
{
sptr = mess_sysop;
mess_sysop = mess_sysop->next;
m_libere (sptr, sizeof (Msysop));
}
libere_serveurs ();
}
#define FIELDS 0x301f /* Mask of the mandatory fields */
static char *inistr[] = {
"vers", /* 0 */
"call", /* 1 */
"ssid", /* 2 */
"qral", /* 3 */
"city", /* 4 */
"conf", /* 5 */
"data", /* 6 */
"mess", /* 7 */
"comp", /* 8 */
"fbbd", /* 9 */
"yapp", /* 10 */
"docs", /* 11 */
"name", /* 12 */
"syso", /* 13 */
"sysm", /* 14 */
"impo", /* 15 */
"logs", /* 16 */
"test", /* 17 */
"fbbf", /* 18 */
"fbbc", /* 19 */
"aski", /* 20 */
"mask", /* 21 */
"secu", /* 22 */
"warn", /* 23 */
"hous", /* 24 */
"time", /* 25 */
"maxd", /* 26 */
"loca", /* 27 */
"beac", /* 28 */
"scro", /* 29 */
"fwdh", /* 30 */
"maxb", /* 31 */
"life", /* 32 */
"wpca", /* 33 */
"zipc", /* 34 */
"unpr", /* 35 */
"upba", /* 36 */
"dwba", /* 37 */
"pg", /* 38 */
"fdir", /* 39 */
"sdir", /* 40 */
"tdir", /* 41 */
"poph", /* 42 */
NULL
};
char *value(char *line, int *key)
{
static char keystr[5];
char *ptr;
int i;
while (isspace(*line))
++line;
if (*line == '#' || *line == '\0')
{
*key = -3;
return line;
}
i = 0;
ptr = keystr;
while (isgraph(*line))
{
if (i++ < 4)
{
*ptr++ = *line;
}
++line;
if (*line == '=')
break;
}
*ptr = '\0';
*key = -1;
for (i = 0 ; inistr[i] ; i++)
{
if (strcasecmp(keystr, inistr[i]) == 0)
{
*key = i;
break;
}
}
line = strchr(line, '=');
if (line)
{
++line;
while (isspace(*line))
++line;
}
else
{
*key = -2;
}
return line;
}
int init_admin (void)
{
static int first = 1;
int ntemp;
char ligne[256];
char stemp[256];
char *ptr = ligne;
char *start;
char *scan;
Msysop *sptr = NULL;
int i, j;
int key;
int val;
int ok_init = 0;
int fond_haut = 0, fond_milieu = 0, fond_bas = 0, fond_menu = 0;
balbul = 0;
nb_ovr = 0;
/* Default values */
BLK_TO = 0;
h_ok = 1;
internal_int = 0xff;
ems_aut = 1;
in_exms = 0;
for (j = 0; j < NB_EMS; j++)
in_exms |= t_ems[j].flag;
FOND_VOIE = 0;
DEF = (fond_haut << 4) + 15;
STA = (fond_milieu << 4) + 15;
INIT = (fond_menu << 4) + 15;
SEND = (fond_bas << 4) + 15;
RECV = (fond_bas << 4) + 15;
HEADER = (fond_bas << 4) + 15;
UI = (fond_bas << 4) + 15;
CONS = (fond_bas << 4) + 15;
INDIC = (fond_bas << 4) + 15;
VOIE = (fond_bas << 4) + 15;
*mypath = '\0';
myssid = 0;
*qra_locator = '\0';
*my_city = '\0';
/* Ne pas reinitialiser */
if (first)
{
int i;
for (i = 0; i < 10; i++)
varx[i] = m_alloue (81);
for (i = 1; i < NBPORT; i++)
t_balise[i] = 900;
}
if (read_fbb_conf(NULL) > 0)
{
no_init_error = 0;
ShowError ("fbb.conf", "Cannot open file", 0);
window_init ();
fbb_quit (0);
return (0);
}
#ifdef __linux__
#ifdef ENGLISH
cprintf ("Parameters set-up \n");
#else
cprintf ("Initialisation des parametres\n");
#endif
#else
#ifdef ENGLISH
cprintf ("Parameters set-up \r\n");
#else
cprintf ("Initialisation des parametres\r\n");
#endif
#endif
libere_serveurs ();
for (key = 0 ; inistr[key] ; key++)
{
ptr = find_fbb_conf(inistr[key], 0);
if (ptr == NULL) {
ptr = def_fbb_conf(inistr[key]);
if (ptr == NULL)
continue;
}
fprintf(stderr, "%4s : %s\n", inistr[key], ptr);
switch (key)
{
case 0:
/* Accept all versions !!
sprintf (stemp, "FBB%s", VERSION);
if (strncasecmp (stemp, ptr, strlen (stemp)) != 0)
{
#ifdef ENGLISH
cprintf ("*** Error : Waiting for fbb.conf version %s \r\n", stemp);
#else
cprintf ("*** Erreur : Version de fbb.conf attendue %s\r\n", stemp);
#endif
err_init (0);
}
*/
ok_init |= (1 << key);
break;
case 1:
strn_cpy (39, mypath, ptr);
if ((j = strlen (mypath)) && (mypath[j - 1] == '.'))
mypath[j - 1] = '\0';
ok_init |= (1 << key);
break;
case 2:
myssid = (char) atoi (ptr);
ok_init |= (1 << key);
break;
case 3:
strn_cpy (10, qra_locator, ptr);
ok_init |= (1 << key);
break;
case 4:
n_cpy (19, my_city, ptr);
ok_init |= (1 << key);
break;
case 5:
n_cpy (80, CONFDIR, test_back_slash (ptr, 0));
break;
case 6:
n_cpy (80, DATADIR, test_back_slash (ptr, 0));
break;
case 7:
n_cpy (80, MESSDIR, test_back_slash (ptr, 0));
break;
case 8:
n_cpy (80, MBINDIR, test_back_slash (ptr, 0));
break;
case 9:
for (j = 0; j < 8; j++)
{
*PATH[j] = '\0';
}
printf("fbbd : <%s>\n", ptr);
scan = strtok (ptr, " ,\t");
for (j = 0; j < 8; j++)
{
printf("%d : {%s}\n", j, scan);
if (scan == NULL)
break;
if (*scan != '*')
{
n_cpy (80, PATH[j] + 2, slash2back (test_back_slash (scan, 0)));
PATH[j][0] = getdisk () + 'A';
PATH[j][1] = ':';
}
scan = strtok (NULL, " ,\t");
printf("%d : {%s}\n", j, PATH[j]);
}
break;
case 10:
n_cpy (80, YAPPDIR+2, slash2back (test_back_slash (ptr, 0)));
YAPPDIR[0] = getdisk () + 'A';
YAPPDIR[1] = ':';
break;
case 11:
n_cpy (80, DOCSDIR, test_back_slash (ptr, 0));
ptr = DOCSDIR + strlen (DOCSDIR) - 1;
if (*ptr == '\\')
*ptr = '\0';
break;
case 12:
n_cpy (12, my_name, ptr);
ok_init |= (1 << key);
break;
case 13:
strn_cpy (6, admin, ptr);
ok_init |= (1 << key);
break;
case 14:
scan = strtok (ptr, " ,\t");
/* Delete la liste existante eventuellement */
while (mess_sysop)
{
sptr = mess_sysop;
mess_sysop = mess_sysop->next;
m_libere (sptr, sizeof (Msysop));
}
if ((scan) && (isalpha (*scan)))
{
sptr = mess_sysop = (Msysop *) m_alloue (sizeof (Msysop));
strn_cpy (20, sptr->call, scan);
}
while ((scan = strtok (NULL, " ,\t")) != NULL)
{
sptr->next = (Msysop *) m_alloue (sizeof (Msysop));
sptr = sptr->next;
strn_cpy (20, sptr->call, scan);
}
break;
case 15:
n_cpy (80, MAILIN, ptr);
n_cpy (76, LOCK_IN, ptr);
start = strrchr (LOCK_IN, '/');
if (start == NULL)
start = LOCK_IN;
scan = strrchr (start, '.');
if (scan)
*scan = '\0';
strcat(LOCK_IN, ".lck");
break;
case 16:
comlog = (toupper (*ptr) == 'O');
break;
case 17:
DEBUG = (toupper (*ptr) == 'O');
miniserv = 0xffff;
watchport = 0;
sscanf (ptr, "%*s %d", &watchport);
break;
case 18:
fbb_fwd = (toupper (*ptr) == 'O');
/*
1 : Espace obligatoire avant le @ dans l'adresse
2 : Ne teste pas la limite a 6 des champs de l'adresse
4 : Ne tronque pas le header a l'espace < 79 caracteres
8 : Header MBL/RLI
16 : Si pas de champ BBS envoie l'indicatif de ma BBS (->PMS)
32 : Supprime les messages data au SYSOP
64 : N'utilise pas le BID cree a partir des headers si pas de BID
128: N'accepte le forward que des BBS declarees.
256: Les messages WP ne sont pas HOLD
512: XWFD has priority on FBB
1024: Alternate BID generation
2048: XFWD with checksum
4096: Simple check for callsigns (3 to 6 chars, 1 digit, 1 alpha).
*/
std_header = 0;
sscanf (ptr, "%*s %d", &std_header);
break;
case 19:
/*
1 : Protocole de niveau 1
*/
bin_fwd = (toupper (*ptr) == 'O');
/*
1 : Binaire FBB version 1
2 : Binaire RLI
*/
ntemp = -1;
sscanf (ptr, "%*s %d", &ntemp);
if ((bin_fwd) & (ntemp != -1) && (ntemp & 1))
{
bin_fwd = 2;
}
prot_fwd = FWD_MBL;
if (fbb_fwd)
{
prot_fwd |= FWD_FBB;
if (bin_fwd)
{
prot_fwd |= FWD_BIN;
if (bin_fwd == 2)
prot_fwd |= FWD_BIN1;
}
}
if ((ntemp == -1) || (ntemp & 2))
prot_fwd |= FWD_XPRO;
break;
case 20:
info_ok = (toupper (*ptr) == 'O');
break;
case 21:
def_mask = (unsigned) atoi (ptr);
break;
case 22:
if (sscanf (ptr, "%u %u %u", &d_droits, &ds_droits, &dss_droits) != 3)
err_init (0);
break;
case 23:
w_mask = (unsigned) atoi (ptr);
break;
case 24:
h_maint = atoi (ptr);
break;
case 25:
if (sscanf (ptr, "%d %d", &time_n, &time_b) != 2)
err_init (0);
time_n *= 60;
time_b *= 60;
break;
case 26:
if (sscanf (ptr, "%d %d", &max_yapp, &max_mod) != 2)
err_init (0);
break;
case 27: /* tzone = 3600 * -atol(ptr) ; */
if (getenv ("TZ") == NULL)
{
/*
memset(_tzname[1], 0, 4);
strcpy(_tzname[0],"GMT");
_timezone = 3600L * -atol(ptr) ;
_daylight = 0; stime
*/
/* Ne pas liberer... Sinon ca plante a l'appel suivant. */
char *tzl = malloc (20);
sprintf (tzl, "TZ=GMT%d", -atoi (ptr));
j = putenv (tzl);
}
tzset ();
break;
case 28:
if (toupper (*ptr) == 'B')
{
balbul = 1;
do
{
++ptr;
}
while (!ISGRAPH (*ptr));
}
max_indic = atoi (ptr);
break;
case 29:
winbuf.totlig = conbuf.totlig = monbuf.totlig = 1500;
sscanf (ptr, "%d %d %d",
&winbuf.totlig, &conbuf.totlig, &monbuf.totlig);
break;
case 30:
txtfwd[0] = '\0';
n_cpy (51, txtfwd + 1, ptr);
if (txtfwd[1])
txtfwd[0] = ' ';
break;
case 31:
maxbbid = atoi (ptr);
if (maxbbid < 0)
maxbbid = 2000;
break;
case 32:
multi_prive = 0;
sscanf (ptr, "%ld %d", &nb_jour_val, &multi_prive);
if (nb_jour_val < 1L)
nb_jour_val = 1L;
break;
case 33:
strn_cpy (256, wp_line, ptr);
break;
case 34:
n_cpy (8, my_zip, ptr);
break;
case 35:
nb_unproto = 300L;
val = 6;
mute_unproto = ack_unproto = via_unproto = priv_unproto = 0;
sscanf (ptr, "%ld %d %s", &nb_unproto, &val, stemp);
scan = strupr (stemp);
while (*scan)
{
switch (*scan)
{
case 'V':
via_unproto = 1;
break;
case 'P':
priv_unproto = 1;
break;
case 'A':
ack_unproto = 1;
break;
case 'M':
mute_unproto = 1;
break;
}
++scan;
}
def_time_bcl = (val * 18);
break;
case 36:
n_cpy (79, BBS_UP, ptr);
break;
case 37:
n_cpy (79, BBS_DW, ptr);
break;
case 38:
n_cpy (80, PGDIR, test_back_slash (ptr, 0));
break;
case 39:
n_cpy (80, FILTDIR, test_back_slash (ptr, 0));
break;
case 40:
n_cpy (80, SERVDIR, test_back_slash (ptr, 0));
break;
case 41:
n_cpy (80, TOOLDIR, test_back_slash (ptr, 0));
break;
case 42:
n_cpy (40, pop_host, ptr);
break;
}
}
/* Read services list */
ptr = find_fbb_conf("serv", 0);
while (ptr)
{
init_serveur (ptr, 0);
ptr = find_fbb_conf("serv", 1);
}
free_fbb_conf();
init_serveur ("WP * Request White pages info", 0);
init_serveur ("REQCFG * Request configuration ", 0);
init_serveur ("REDIST * Bulletin redistribution ", 0);
i = 0;
ptr = mypath;
while (isalnum (*ptr))
{
mycall[i] = *ptr++;
if (++i == 6)
break;
}
mycall[i] = '\0';
ind_console (1, mycall);
strcpy (my_call, cons_call.call);
if (first)
window_init ();
set_win_colors ();
first = 0;
if (ok_init != FIELDS)
{
int mask = 1;
for (i = 0 ; i < 32 ; i++)
{
if (((mask << i) & FIELDS) && (((mask << i) & ok_init) == 0))
{
#ifdef ENGLISH
cprintf ("*** Error : Mandatory field \"%s\" missing in fbb.conf \r\n", inistr[i]);
#else
cprintf ("*** Erreur : Le champ \"%s\" n'est pas defini dans fbb.conf\r\n", inistr[i]);
#endif
}
}
err_init (0);
no_init_error = 0;
}
return (no_init_error);
}
static void cree_etat (void)
{
FILE *fichier;
if ((fichier = fopen (d_disque ("ETAT.SYS"), "wt")) == NULL)
{
fbb_error (ERR_CREATE, d_disque ("ETAT.SYS"), 0);
}
fprintf (fichier, "%-6s-%d\n", mycall, myssid);
ind_console (1, mycall);
fprintf (fichier, "Mise en service par %s-%d le %s\n",
cons_call.call, cons_call.num, strdate (time (NULL)));
fclose (fichier);
}
void init_etat (void)
{
FILE *fichier;
char s[81];
if ((fichier = fopen (d_disque ("ETAT.SYS"), "r+t")) == NULL)
{
if (err_ouvert ("ETAT.SYS"))
{
cree_etat ();
arret = FALSE;
}
else
fbb_error (ERR_OPEN, d_disque ("ETAT.SYS"), 0);
}
else
{
fgets (s, 80, fichier);
ind_console (1, sup_ln (s));
if (fgetc (fichier) == 'A')
arret = TRUE;
else
arret = FALSE;
fclose (fichier);
}
}
fbb-7.0.11/src/mbl_lc.c 0000664 0001750 0001750 00000006360 13613525371 011452 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
#include
/*
* Module commande LC
*/
#define NB_THEMES 1000
static void list_themes (void);
typedef struct theme
{
char nom[6];
int nb;
struct theme *suiv;
}
Theme;
int list_lc (void)
{
int error = 0;
sup_ln (indd);
/************** Tester l'espace ******************/
incindd ();
if ((*indd == ';') || (*indd == '?'))
list_themes ();
else
{
if (*indd)
{
strn_cpy (6, pvoie->finf.filtre, indd);
if (strcmp (pvoie->finf.filtre, "*") == 0)
{
*pvoie->finf.filtre = '\0';
}
}
outln ("=> $l", 5);
}
retour_mbl ();
return (error);
}
static void list_themes (void)
{
char s[30];
char temp[30];
Theme *tptr = NULL;
Theme *cptr;
Theme *sptr;
Theme *prec;
int nb;
int comp;
unsigned offset;
bloc_mess *bptr = tete_dir;
bullist ligne;
ouvre_dir ();
offset = 0;
while (bptr)
{
if (bptr->st_mess[offset].noenr)
{
read_dir (bptr->st_mess[offset].noenr, &ligne);
if ((ligne.type == 'B') && (droit_ok (&ligne, 1)))
{
if (tptr == NULL)
{
tptr = (Theme *) m_alloue (sizeof (Theme));
tptr->suiv = NULL;
strncpy (tptr->nom, ligne.desti, 6);
tptr->nb = 1;
}
else
{
prec = NULL;
sptr = tptr;
for (;;)
{
if (sptr == NULL)
{
cptr = (Theme *) m_alloue (sizeof (Theme));
cptr->suiv = NULL;
strncpy (cptr->nom, ligne.desti, 6);
cptr->nb = 1;
if (prec)
prec->suiv = cptr;
else
tptr = cptr;
break;
}
comp = strncmp (sptr->nom, ligne.desti, 6);
if (comp == 0)
{
++sptr->nb;
break;
}
if (comp > 0)
{
cptr = (Theme *) m_alloue (sizeof (Theme));
strncpy (cptr->nom, ligne.desti, 6);
cptr->nb = 1;
if (prec)
prec->suiv = cptr;
else
tptr = cptr;
cptr->suiv = sptr;
break;
}
prec = sptr;
sptr = sptr->suiv;
}
}
}
}
if (++offset == T_BLOC_MESS)
{
bptr = bptr->suiv;
offset = 0;
}
}
ferme_dir ();
nb = 0;
cptr = tptr;
while (cptr)
{
strn_cpy (6, temp, cptr->nom);
sprintf (s, "%-6s %d ", temp, cptr->nb);
out (s, 13);
if (++nb == 6)
{
cr ();
nb = 0;
}
prec = cptr;
cptr = cptr->suiv;
m_libere (prec, sizeof (Theme));
}
if (nb != 0)
cr ();
}
fbb-7.0.11/src/epurwp.c 0000664 0001750 0001750 00000041773 13747454246 011565 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
#define ENGLISH
/*
* Mise a jour des WP en fonction de la date
*
*/
#include
#include
#include
#include
#include
#include
#ifdef __linux__
#include
#include
#else
#include
#include
#endif
#include
#include
#ifdef __linux__
#define __a2__ __attribute__ ((packed, aligned(2)))
#define O_BINARY 0
#define _read read
#define _write write
#else
#define __a2__
#endif
#define uchar unsigned char
#define lcall unsigned long
typedef struct
{ /* 194 bytes */
char callsign[7];
char name[13];
uchar free;
uchar changed;
unsigned short seen;
long last_modif __a2__;
long last_seen __a2__;
char first_homebbs[41];
char secnd_homebbs[41];
char first_zip[9];
char secnd_zip[9];
char first_qth[31];
char secnd_qth[31];
}
Wps;
lcall zone[1000];
int addr_check = 1;
int ext_call = 0;
unsigned deb_zone;
long tst_date;
long kill_date;
long heure;
long record = 0L;
long lines_out = 0L;
long record_in = 0L;
long record_out = 0L;
long update = 0L;
long destroy = 0L;
long dupes = 0L;
Wps rec;
char wp_sys[256];
char wp_old[256];
char wp_mess[256];
char upd_file[256];
char compte_rendu[256];
void defauts (int, int);
void print_compte_rendu (void);
void strn_cpy (char *, char *, int);
void init_zone (long);
void add_zone (Wps *);
char *date_mbl_new (long);
char *strdt (long);
void wp_message (Wps *);
lcall call2l (char *);
int addr_ok (char *s);
int find (char *);
int copy_ (char *, char *);
int check_record (Wps * rec);
FILE *fpti;
FILE *fpto;
FILE *fptr_mess;
FILE *fptr_upd;
#ifdef __linux__
char *strupr (char *str)
{
char *tmp = str;
while (*tmp)
{
if (islower (*tmp))
*tmp = toupper (*tmp);
++tmp;
}
return str;
}
char *strlwr (char *str)
{
char *tmp = str;
while (*tmp)
{
if (isupper (*tmp))
*tmp = tolower (*tmp);
++tmp;
}
return str;
}
long filelength (int fd)
{
struct stat st;
int val;
val = fstat (fd, &st);
if (val == -1)
return (-1L);
return (st.st_size);
}
#endif
char *test_back_slash (char *chaine)
{
static char temp[256];
strcpy(temp, chaine);
if ((strlen(temp) == 0)
#ifdef __linux__
|| (temp[strlen (temp) - 1] != '/'))
strcat(temp, "/");
#else
|| (temp[strlen (temp) - 1] != '\\'))
strcat(temp, "\\");
#endif
return (temp);
}
void err_keyword(char *keyword)
{
fprintf(stderr, "Error : keyword \"%s\"missing in fbb.conf file\n", keyword);
exit(1);
}
void epure (char *ligne)
{
int lg;
lg = strlen (ligne);
if (ligne[lg - 1] == '\n')
ligne[lg - 1] = '\0';
lg = strlen (ligne);
if (ligne[lg - 1] == '\r')
ligne[lg - 1] = '\0';
if (*ligne == '\032')
*ligne = '\0';
}
int main (int ac, char **av)
{
int status;
int jours = 40;
int obsolete = 90;
int deb_zone = 0xffff;
*upd_file = '\0';
if ((ac >= 2) && (strcmp (strupr (av[1]), "/H") == 0))
{
fprintf (stderr, "\nEPURWP V%s\n", VERSION);
fprintf (stderr, "format : EPURWP [upd-days [kill-days [update-file]]]\n");
fprintf (stderr, "defaults: upd-days = 40\n kill-days= 90\n\n");
fprintf (stderr, "If temporary part is stable during \"upd-days\" days,\n");
fprintf (stderr, "temporary part updates main part of WP\n\n");
fprintf (stderr, "If the callsign is not seen during \"kill-days\" days,\n");
fprintf (stderr, "callsign is deleted from WP database\n\n");
fprintf (stderr, "\"update-file\" stores the WP records corresponding to the\n");
fprintf (stderr, "updates in a file which can be processed later (eg for statistics)\n\n");
exit (0);
}
if (strncmp (strupr (av[ac - 1]), "/NOC", 4) == 0)
{
addr_check = 0;
--ac;
}
if (ac >= 2)
jours = atoi (av[1]);
if (ac >= 3)
obsolete = atoi (av[2]);
if (ac >= 4)
strcpy (upd_file, av[3]);
/*
if (ac >= 4)
deb_zone = (unsigned)atoi(av[3]) * 1000;
*/
fprintf (stderr, "\nEpurwp V%s\n\n", VERSION);
heure = time (NULL);
defauts (jours, obsolete);
#ifdef ENGLISH
fprintf (stderr, "Updating white pages database \n");
fprintf (stderr, " Update time is %d days\n", jours);
if (obsolete)
fprintf (stderr, " Delete time is %d days\n\n", obsolete);
#else
fprintf (stderr, "Mise … jour de la base de donn‚es\n");
fprintf (stderr, " D‚lai : %d jours\n", jours);
if (obsolete)
fprintf (stderr, " Suppression : %d jours\n\n", obsolete);
#endif
if ((fptr_mess = fopen (wp_mess, "at")) == NULL)
{
#ifdef ENGLISH
fprintf (stderr, "Cannot create '%s' \n", wp_mess);
#else
fprintf (stderr, "Erreur creation '%s'\n", wp_mess);
#endif
exit (1);
}
#ifdef ENGLISH
fprintf (stderr, "%s - Saves WP.SYS file into WP.OLD file \n\n", date_mbl_new (time (NULL)));
#else
fprintf (stderr, "%s - Sauvegarde du fichier WP.SYS en WP.OLD\n\n", date_mbl_new (time (NULL)));
#endif
if (!copy_ (wp_sys, wp_old))
{
unlink (wp_old);
exit (2);
}
if ((fpti = fopen (wp_old, "rb")) == NULL)
{
#ifdef ENGLISH
fprintf (stderr, "Cannot open '%s' \n", wp_old);
#else
fprintf (stderr, "Erreur ouverture '%s'\n", wp_old);
#endif
exit (3);
}
if ((fpto = fopen (wp_sys, "wb")) == NULL)
{
#ifdef ENGLISH
fprintf (stderr, "Cannot open '%s' \n", wp_sys);
#else
fprintf (stderr, "Erreur ouverture '%s'\n", wp_sys);
#endif
exit (4);
}
if (*upd_file)
{
if ((fptr_upd = fopen (upd_file, "ab")) == NULL)
{
#ifdef ENGLISH
fprintf (stderr, "Cannot open '%s' \n", upd_file);
#else
fprintf (stderr, "Erreur ouverture '%s'\n", upd_file);
#endif
exit (5);
}
}
else
fptr_upd = NULL;
init_zone (filelength (fileno (fpti)) / (long) sizeof (Wps));
while (fread (&rec, sizeof (Wps), 1, fpti))
{
status = check_record (&rec);
if (record_in >= deb_zone)
add_zone (&rec);
if (status == 2)
++update;
if (status)
{
if (fwrite (&rec, sizeof (Wps), 1, fpto) == 0)
{
#ifdef ENGLISH
fprintf (stderr, "Error while writing file '%s'\n", wp_sys);
#else
fprintf (stderr, "Erreur ecriture fichier '%s' \n", wp_sys);
#endif
exit (1);
}
++record_out;
}
else if (rec.last_modif)
++destroy;
if ((*rec.callsign) && ((++record % 100) == 0))
#ifdef __linux__
fprintf (stderr, "\nRecord %ld", record);
#else
fprintf (stderr, "\rRecord %ld", record);
#endif
++record_in;
}
#if 0
memset (&rec, '\0', sizeof (Wps));
while (record_out < record_in)
{
fseek (fpto, record_out * sizeof (Wps), SEEK_SET);
if (fwrite (&rec, sizeof (Wps), 1, fpto) == 0)
{
#ifdef ENGLISH
fprintf (stderr, "Error while writing file '%s'\n", wp_sys);
#else
fprintf (stderr, "Erreur ecriture fichier '%s' \n", wp_sys);
#endif
exit (1);
}
++record_out;
}
#endif
if (fptr_upd)
fclose (fptr_upd);
fclose (fpti);
fclose (fpto);
fclose (fptr_mess);
fprintf (stderr, "\rRecord %ld\n\n", record);
print_compte_rendu ();
return (0);
}
void init_zone (long lg)
{
int i;
long nbbloc = (lg / 1000L) + 1L;
if (deb_zone == 0xffff)
deb_zone = 1000 * (unsigned) (heure % nbbloc);
/*
printf("%ld records, %ld blocs, heure = %ld zone = %u\n",
lg, nbbloc, heure, deb_zone);
*/
for (i = 0; i < 1000; i++)
zone[i] = 0L;
}
int is_dupe (Wps * rec)
{
lcall lc;
int i;
lc = call2l (rec->callsign);
for (i = 0; i < 1000; i++)
{
if (lc == zone[i])
{
++dupes;
fprintf (stderr, "\rRecord %ld (%s) duplicated\n", record, rec->callsign);
return (1);
}
}
return (0);
}
void add_zone (Wps * rec)
{
static int index = 0;
if (index == 1000)
return;
zone[index++] = call2l (rec->callsign);
}
int check_record (Wps * rec)
{
int modif = 1;
rec->callsign[6] = '\0';
rec->name[12] = '\0';
rec->first_homebbs[40] = '\0';
rec->secnd_homebbs[40] = '\0';
rec->first_zip[8] = '\0';
rec->secnd_zip[8] = '\0';
rec->first_qth[30] = '\0';
rec->secnd_qth[30] = '\0';
if ((!find (rec->callsign)) || (*rec->first_homebbs == '\0') || (*rec->first_homebbs == '?'))
return (0);
if ((addr_check) && (!addr_ok (rec->first_homebbs)))
{
return (0);
}
if (is_dupe (rec))
return (0);
if (rec->last_seen < kill_date)
{
/* Entree obsolete */
return (0);
}
if (rec->last_modif < tst_date)
{
/* Mise a jour */
if (strncmp (rec->first_homebbs, rec->secnd_homebbs, 40) != 0)
{
strn_cpy (rec->first_homebbs, rec->secnd_homebbs, 40);
modif = 2;
}
if (strncmp (rec->first_zip, rec->secnd_zip, 8) != 0)
{
strn_cpy (rec->first_zip, rec->secnd_zip, 8);
modif = 2;
}
if (strncmp (rec->first_qth, rec->secnd_qth, 30) != 0)
{
strn_cpy (rec->first_qth, rec->secnd_qth, 30);
modif = 2;
}
}
if (rec->changed)
{
wp_message (rec);
rec->changed = 0;
}
return (modif);
}
void print_compte_rendu (void)
{
FILE *fcr;
#ifdef ENGLISH
printf ("\n");
printf ("WP updated : %5ld total records \n", record);
printf (" : %5ld updated record(s) \n", update);
printf (" : %5ld deleted record(s) \n", destroy);
printf (" : %5ld WP update line(s) \n\n", lines_out);
if ((fcr = fopen (compte_rendu, "wt")) != NULL)
{
fprintf (fcr, "%ld\n\n", heure);
fprintf (fcr, "WP updated : %5ld total record(s) \n", record);
fprintf (fcr, " : %5ld updated record(s) \n", update);
fprintf (fcr, " : %5ld deleted records(s) \n", destroy);
fprintf (fcr, " : %5ld WP update line(s) \n\n", lines_out);
fprintf (fcr, "Start computing : %s\n", strdt (heure));
fprintf (fcr, "End computing : %s\n", strdt (time (NULL)));
fclose (fcr);
}
#else
printf ("\n");
printf ("Pages Blanches : %5ld enregistrement(s)\n", record);
printf (" : %5ld mise(s) … jour \n", update);
printf (" : %5ld suppression(s) \n", destroy);
printf (" : %5ld lignes de m.a.j. \n\n", lines_out);
if ((fcr = fopen (compte_rendu, "wt")) != NULL)
{
fprintf (fcr, "%ld\n\n", heure);
fprintf (fcr, "Pages Blanches : %5ld enregistrement(s)\n", record);
fprintf (fcr, " : %5ld mise(s) … jour \n", update);
fprintf (fcr, " : %5ld suppression(s) \n", destroy);
fprintf (fcr, " : %5ld lignes de m.a.j. \n\n", lines_out);
fprintf (fcr, "Debut du traitement : %s\n", strdt (heure));
fprintf (fcr, "Fin du traitement : %s\n", strdt (time (NULL)));
fclose (fcr);
}
#endif
}
void defauts (int jours, int obsolete)
{
unsigned int flag;
char *ptr;
char system_dir[256];
char temp[20];
if (read_fbb_conf(NULL) > 0)
{
#ifdef ENGLISH
fprintf (stderr, "Cannot open fbb.conf file \n");
#else
fprintf (stderr, "Erreur ouverture fichier fbb.conf\n");
#endif
exit (1); /* and users base directory */
}
ptr = find_fbb_conf("vers", 0);
if (ptr == NULL)
{
#ifdef ENGLISH
fprintf (stderr, "Version number missing in fbb.conf\n");
#else
fprintf (stderr, "Pas de numéro dans le fbb.conf\n");
#endif
exit (1);
}
sprintf (temp, "FBB%s", VERSION);
/* Only test the major number ... */
if (strncasecmp (temp, ptr, 4) != 0)
{
#ifdef ENGLISH
fprintf (stderr, "Wrong version number in fbb.conf\n");
#else
fprintf (stderr, "Numéro de version erroné dans fbb.conf\n");
#endif
exit (1);
}
#ifdef __linux__
fprintf (stderr, "Configuration version : %s\n", ptr);
#else
fprintf (stderr, "Configuration version : %s\r", ptr);
#endif
/* path of conf files */
ptr = find_fbb_conf("data", 0);
if (ptr == NULL)
ptr = def_fbb_conf("data");
if (ptr == NULL)
err_keyword("data");
strcpy (system_dir, test_back_slash(strlwr (ptr)));
/* flags */
ptr = find_fbb_conf("fbbf", 0);
if (ptr == NULL)
ptr = def_fbb_conf("fbbf");
if (ptr == NULL)
err_keyword("fbbf");
flag = 0;
sscanf (ptr, "%s %u", temp, &flag);
ext_call = ((flag & 4096) != 0);
#ifdef __linux__
sprintf (wp_sys, "%swp/wp.sys", system_dir);
sprintf (wp_old, "%swp/wp.old", system_dir);
sprintf (wp_mess, "%swp/mess.wp", system_dir);
strcpy (compte_rendu, "epurwp.res");
#else
sprintf (wp_sys, "%sWP\\WP.SYS", system_dir);
sprintf (wp_old, "%sWP\\WP.OLD", system_dir);
sprintf (wp_mess, "%sWP\\MESS.WP", system_dir);
strcpy (compte_rendu, "EPURWP.RES");
#endif
tst_date = heure - (long) jours *86400L;
kill_date = heure - (long) obsolete *86400L;
}
char *strdt (long temps)
{
struct tm *sdate;
static char cdate[80];
sdate = localtime (&temps);
#ifdef ENGLISH
sprintf (cdate, "%02d-%02d-%02d %02d:%02d",
sdate->tm_year % 100,
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 % 100,
sdate->tm_hour,
sdate->tm_min);
#endif
return (cdate);
}
char *date_mbl_new (long temps)
{
struct tm *sdate;
static char cdate[40];
sdate = localtime (&temps);
#ifdef ENGLISH
sprintf (cdate, "%02d-%02d-%02d", sdate->tm_year % 100, sdate->tm_mon + 1, sdate->tm_mday);
#else
sprintf (cdate, "%02d/%02d/%02d", sdate->tm_mday, sdate->tm_mon + 1, sdate->tm_year % 100);
#endif
return (cdate);
}
void strn_cpy (char *dest, char *source, int len)
{
for (;;)
{
if ((len-- == 0) || (*source == '\0'))
break;
*dest++ = *source++;
}
*dest = '\0';
}
int find (char *s)
{
char *t = s;
int n = 0;
int dernier = 0, chiffre = 0, lettre = 0;
while (isalnum (*t))
{
*t = toupper (*t);
dernier = (isdigit (*t));
if (isdigit (*t))
++chiffre;
else
++lettre;
++t;
++n;
}
*t = '\0';
if (ext_call)
{
/*
* 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 (0);
}
else
{
/*
* L'indicatif doit avoir entre 3 et 6 caracteres .
* doit contenir 1 ou 2 chiffres .
* ne doit pas se terminer par un chiffre .
*/
if ((n < 3) || (n > 6) || (chiffre < 1) || (chiffre > 2) || dernier)
return (0);
}
return (1);
}
static char *wp_date_mbl (long temps)
{
struct tm *sdate;
static char cdate[7];
sdate = localtime (&temps);
sprintf (cdate, "%02d%02d%02d", sdate->tm_year % 100, sdate->tm_mon + 1, sdate->tm_mday);
return (cdate);
}
void wp_message (Wps * rec)
{
if (fptr_upd)
{
fwrite (rec, sizeof (Wps), 1, fptr_upd);
}
if ((rec->changed == 'U') || (rec->changed == 'G') || (rec->changed == 'I'))
{
fprintf (fptr_mess, "On %s %s/%c @ %s zip %s %s %s\n",
wp_date_mbl (rec->last_modif),
rec->callsign,
rec->changed,
(*rec->secnd_homebbs) ? rec->secnd_homebbs : "?",
(*rec->secnd_zip) ? rec->secnd_zip : "?",
(*rec->name) ? rec->name : "?",
(*rec->secnd_qth) ? rec->secnd_qth : "?"
);
++lines_out;
}
}
#if 0
int copy_ (char *oldfich, char *newfich)
{
char s[256];
#ifdef __linux__
sprintf (s, "cp %s %s > /dev/null", oldfich, newfich);
#else
sprintf (s, "COPY %s %s > NUL", oldfich, newfich);
#endif
system (s);
return (1);
}
#endif
#define TAIBUF 16384
static char buffer[TAIBUF];
int copy_ (char *oldfich, char *newfich)
{
int retour = 1;
int fd_orig;
int fd_dest;
int nb_lus;
int ret;
int dest_access;
if ((fd_orig = open (oldfich, O_RDONLY | O_BINARY, S_IREAD | S_IWRITE)) == EOF)
{
fprintf (stderr, "Cannot find %s\n", oldfich);
return (0);
}
dest_access = O_WRONLY | O_CREAT | O_TRUNC | O_BINARY;
if ((fd_dest = open (newfich, dest_access, S_IREAD | S_IWRITE)) == EOF)
{
close (fd_orig);
fprintf (stderr, "Cannot create %s\n", newfich);
return (0);
}
for (;;)
{
nb_lus = _read (fd_orig, buffer, TAIBUF);
if (nb_lus == -1)
{
retour = 0;
break;
}
if (nb_lus == 0)
{
retour = 1;
break;
}
ret = _write (fd_dest, buffer, nb_lus);
if (ret != nb_lus)
{
retour = 0;
break;
}
}
close (fd_orig);
close (fd_dest);
return (retour);
}
lcall call2l (char *callsign)
{
char *ptr = callsign;
int c;
lcall val = 0L;
while ((c = (int) *ptr++) != 0)
{
if (c < 48)
return (0xffffffffL);
c -= 47;
if (c > 10)
{
c -= 7;
if (c > 36)
{
return (0xffffffffL);
}
else if (c < 11)
{
return (0xffffffffL);
}
}
val *= 37;
val += c;
}
return (val);
}
int addr_ok (char *s)
{
int nb = 0;
int total = 0;
while (*s)
{
if (*s == '.')
{
nb = 0;
}
else
{
if (nb == 6)
{
return (0);
}
++nb;
}
++s;
if (++total == 31)
return (0);
}
return (1);
}
fbb-7.0.11/src/mbl_list.c 0000664 0001750 0001750 00000042315 13613525371 012027 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
#include
/*
* Module Nø1 emulation WA7MBL
*/
static int mbl_lx (void);
static int mbl_bloc_liste (void);
static int strfind (bullist *, char *);
static int teste_liste (bullist *);
static int mess_bloc_liste (void);
static void list_mine (char);
/* Commande 'L' -> List messages */
#include "aff_stat.c"
static int strfind (bullist * pbul, char *cherche)
{
return (strmatch (ltitre (1, pbul), cherche));
}
static int manque_forward (bullist * lbul)
{
int i;
if ((*lbul->bbsv) && (lbul->status == 'N'))
{
for (i = 0; i < NBMASK; i++)
if (lbul->fbbs[i])
return (0);
return (1);
}
return (0);
}
static int teste_liste (bullist * lbul)
{
if (lbul->numero < pvoie->recliste.debut)
return (0);
if (lbul->numero > pvoie->recliste.fin)
return (0);
if (lbul->date < pvoie->recliste.avant)
return (0);
if (lbul->date > pvoie->recliste.apres)
return (0);
if (!droits (COSYSOP))
{
if (strcmp (lbul->desti, "KILL") == 0)
return (0);
if (lbul->type == 'A')
return (0);
if ((lbul->status == 'K') && (pvoie->recliste.status != 'K'))
return (0);
if ((lbul->status == 'A') && (pvoie->recliste.status != 'A'))
return (0);
}
if ((pvoie->recliste.type) && (pvoie->recliste.type != lbul->type))
return (0);
if ((pvoie->recliste.status) && (pvoie->recliste.status != lbul->status))
return (0);
if ((pvoie->recliste.route) && (!manque_forward (lbul)))
return (0);
if ((*pvoie->recliste.exp) && (!strmatch (lbul->exped, pvoie->recliste.exp)))
return (0);
if ((*pvoie->recliste.dest) && (!strmatch (lbul->desti, pvoie->recliste.dest)))
return (0);
if (*pvoie->recliste.find)
return (strfind (lbul, pvoie->recliste.find));
if (*pvoie->recliste.bbs)
{
if (*pvoie->recliste.bbs == '-')
{
if (*lbul->bbsv)
return (0);
}
else
{
if (!strmatch (bbs_via (lbul->bbsv), pvoie->recliste.bbs))
return (0);
}
}
return (1);
}
static int mbl_bloc_liste (void)
{
int retour = 1;
unsigned offset = pvoie->recliste.offset;
bloc_mess *bptr = pvoie->recliste.ptemp;
bullist ligne;
pvoie->sr_mem = pvoie->seq = FALSE;
ouvre_dir ();
while (bptr)
{
if (!pvoie->reverse)
--offset;
if (bptr->st_mess[offset].noenr)
{
read_dir (bptr->st_mess[offset].noenr, &ligne);
if (ligne.numero < pvoie->recliste.debut)
break;
if ((ligne.type) && (droit_ok (&ligne, 1)) && (teste_liste (&ligne)))
{
if (pvoie->recliste.last-- == 0L)
break;
if (pvoie->temp1)
{
pvoie->temp2 -= entete_liste ();
pvoie->temp1 = 0;
}
aff_status (&ligne);
--pvoie->temp2;
}
}
if (pvoie->reverse)
{
if (++offset == T_BLOC_MESS)
{
bptr = bptr->suiv;
offset = 0;
}
}
else
{
if (offset == 0)
{
bptr = prec_dir (bptr);
offset = T_BLOC_MESS;
}
}
if (pvoie->temp2 == 0)
{
retour = 2;
break;
}
if (pvoie->memoc >= MAXMEM)
{
pvoie->sr_mem = TRUE;
retour = 0;
break;
}
if (trait_time > MAXTACHE)
{
pvoie->seq = TRUE;
retour = 0;
break;
}
}
ferme_dir ();
pvoie->recliste.offset = offset;
pvoie->recliste.ptemp = bptr;
if ((retour) && (pvoie->temp1))
texte (T_MBL + 3);
return (retour);
}
void mess_liste (int pr)
{
int mode_list = 1;
int verbose = 0;
switch (pvoie->niv3)
{
case 0:
pvoie->temp1 = 1;
pvoie->temp2 = pvoie->lignes;
ch_niv3 (1);
break;
case 1:
break;
case 2:
while_space ();
switch (toupper (*indd))
{
case 'A':
mode_list = 0;
retour_mbl ();
break;
case 'V':
verbose = 1;
case 'R':
mode_list = 0;
incindd ();
if (isdigit (*indd))
{
list_read (verbose);
pvoie->sr_mem = 1;
if (mbl_mess_read () == 0)
{
pvoie->sr_mem = 0;
texte (T_QST + 6);
}
}
else
{
texte (T_ERR + 3);
texte (T_QST + 6);
}
break;
default:
pvoie->temp2 = pvoie->lignes;
ch_niv3 (1);
break;
}
break;
case 3:
mode_list = 0;
if (read_mess (1) == 0)
ch_niv3 (4);
break;
case 4:
mode_list = 0;
pvoie->sr_mem = 1;
if (mbl_mess_read () == 0)
{
pvoie->sr_mem = 0;
texte (T_QST + 6);
ch_niv3 (2);
}
break;
default:
fbb_error (ERR_NIVEAU, "MESS-LIST", pvoie->niv3);
}
if (mode_list)
{
if (pr)
{
pvoie->lignes = -1;
switch (mess_bloc_liste ())
{
case 0:
break;
case 1:
retour_mbl ();
break;
case 2:
texte (T_QST + 6);
ch_niv3 (2);
break;
}
}
else
{
pvoie->lignes = -1;
#if 0
switch (mess_bloc_liste ())
{
case 0:
break;
case 1:
retour_mbl ();
break;
case 2:
ch_niv3 (1);
break;
}
#else
mess_bloc_liste ();
pvoie->sr_mem = pvoie->seq = FALSE;
libere_tread (voiecur);
libere_tlist (voiecur);
pvoie->mbl = 1;
maj_niv (N_MBL, 0, 0);
#endif
}
}
}
static int mess_bloc_liste (void)
{
int retour = 1;
rd_list *ptemp;
bullist ligne;
mess_noeud *mptr;
pvoie->sr_mem = pvoie->seq = FALSE;
ouvre_dir ();
while ((ptemp = pvoie->t_list) != NULL)
{
if (pvoie->temp1)
{
pvoie->temp1 = 0;
entete_liste ();
--pvoie->temp2;
}
mptr = findmess (ptemp->nmess);
if (mptr)
{
read_dir (mptr->noenr, &ligne);
aff_status (&ligne);
}
--pvoie->temp2;
pvoie->t_list = pvoie->t_list->suite;
m_libere (ptemp, sizeof (rd_list));
if (pvoie->temp2 == 0)
{
retour = 2;
break;
}
if (pvoie->memoc >= MAXMEM)
{
pvoie->sr_mem = TRUE;
retour = 0;
break;
}
if (trait_time > MAXTACHE)
{
pvoie->seq = TRUE;
retour = 0;
break;
}
}
ferme_dir ();
if ((retour) && (pvoie->temp1))
texte (T_MBL + 3);
return (retour);
}
static void list_mine (char mode)
{
char s[2];
int nouveau = 0;
unsigned num_ind;
if (isdigit (mode))
{
s[0] = mode;
s[1] = '\0';
insnoeud (s, &num_ind);
}
else
{
if (mode == 'N')
nouveau = TRUE;
num_ind = pvoie->no_indic;
}
list_messages (nouveau, num_ind, 1);
}
void send_list(int voie)
{
unsigned offset;
bloc_mess *bptr = tete_dir;
mess_noeud *mptr;
bullist bul;
char buf[80];
sprintf(buf, "S%d", svoie[voie]->ncur->nbmess);
sta_drv (voie, SNDCMD, buf);
ouvre_dir ();
/* Read messages */
while (bptr)
{
for (offset = 0 ; offset < T_BLOC_MESS ; offset++)
{
mptr = &(bptr->st_mess[offset]);
if ((mptr->noenr) && (mptr->no_indic == svoie[voie]->no_indic))
{
read_dir (mptr->noenr, &bul);
if (bul.status != 'N' && bul.status != 'K' && bul.status != 'A')
{
sprintf(buf, "M%ld %ld %c", bul.numero, bul.taille, bul.status);
sta_drv (voie, SNDCMD, buf);
}
}
}
bptr = bptr->suiv;
}
bptr = tete_dir;
/* Unread messages */
while (bptr)
{
for (offset = 0 ; offset < T_BLOC_MESS ; offset++)
{
mptr = &(bptr->st_mess[offset]);
if ((mptr->noenr) && (mptr->no_indic == svoie[voie]->no_indic))
{
read_dir (mptr->noenr, &bul);
if (bul.status == 'N')
{
sprintf(buf, "M%ld %ld %c", bul.numero, bul.taille, bul.status);
sta_drv (voie, SNDCMD, buf);
}
}
}
bptr = bptr->suiv;
}
ferme_dir ();
sta_drv (voie, SNDCMD, "M0 0 N");
}
void list_messages (int nouveau, unsigned num_ind, int pr)
{
int trouve = 0;
unsigned offset = 0;
bloc_mess *bptr = tete_dir;
mess_noeud *mptr;
rd_list *ptemp = NULL;
bullist bul;
ouvre_dir ();
/* pvoie->typlist = 0; */
while (bptr->suiv)
bptr = bptr->suiv;
while (bptr)
{
offset = T_BLOC_MESS;
while (offset--)
{
mptr = &(bptr->st_mess[offset]);
if ((mptr->noenr) && (mptr->no_indic == num_ind))
{
read_dir (mptr->noenr, &bul);
if (((!nouveau) || (nouveau && (bul.status == 'N')))
&& (bul.status != 'H') && (bul.status != 'A'))
{
if (ptemp)
{
ptemp->suite = (rd_list *) m_alloue (sizeof (rd_list));
ptemp = ptemp->suite;
}
else
{
pvoie->t_list = ptemp = (rd_list *) m_alloue (sizeof (rd_list));
}
ptemp->suite = NULL;
ptemp->nmess = mptr->nmess;
ptemp->verb = 1;
trouve = 1;
}
}
}
bptr = prec_dir (bptr);
}
ferme_dir ();
if (!trouve)
{
if (nouveau)
texte (T_MBL + 4);
else
texte (T_MBL + 3);
retour_mbl ();
}
else
{
maj_niv (N_MBL, 16, 0);
mess_liste (pr);
}
}
static int copy_word(char *dest, char *str, int max)
{
int nb = 0;
while (!isspace(*str) && !iscntrl(*str))
{
*dest++ = *str++;
++nb;
if (max && nb == max)
break;
}
*dest = '\0';
return nb;
}
static int cmd_list(int cmd)
{
char cde;
int ok = 1;
long date;
switch (cmd)
{
case 'A':
pvoie->recliste.status = 'A';
break;
case 'B':
pvoie->recliste.type = 'B';
break;
case 'D':
cde = *indd++;
if ((cde == '<') || (cde == '>'))
{
if (teste_espace ())
{
if ((date = date_to_time (indd)) == 0L)
{
ok = 0;
texte (T_ERR + 3);
}
else
{
char tmp[20];
indd += copy_word(tmp, indd, 19);
switch (cde)
{
case '>':
pvoie->recliste.avant = date /* + 86400L */ ;
break;
case '<':
pvoie->recliste.apres = date - 86400L;
break;
}
}
}
else
{
texte (T_ERR + 2);
ok = 0;
}
}
else
{
ok = 0;
sprintf (varx[0], "LD%c", cmd);
texte (T_ERR + 1);
}
break;
case 'E':
pvoie->recliste.route = 1;
break;
case 'F':
pvoie->recliste.status = 'F';
break;
case 'H':
pvoie->temp1 = 0;
list_held ();
ok = 0;
break;
case 'K':
pvoie->recliste.status = 'K';
break;
case 'L':
if (!ISPRINT (*indd))
{
pvoie->recliste.last = 1;
}
else if (teste_espace ())
{
if (isdigit (*indd))
pvoie->recliste.last = lit_chiffre (0);
else
{
texte (T_ERR + 3);
ok = 0;
}
}
else
{
texte (T_ERR + 2);
ok = 0;
}
break;
case 'M':
case 'N':
list_mine (cmd);
ok = 2;
break;
case 'P':
pvoie->recliste.type = 'P';
break;
case 'S':
if (teste_espace ())
{
int len = 0;
char *ptr = indd;
while (*ptr && *ptr != ' ')
{
++ptr;
++len;
}
pvoie->recliste.find[0] = '*';
strn_cpy ((len > 17) ? 17 : len, (pvoie->recliste.find) + 1, strupr (indd));
indd += len;
strcat (pvoie->recliste.find, "*");
}
else
{
texte (T_ERR + 2);
ok = 0;
}
break;
case 'T':
pvoie->recliste.type = 'T';
break;
case 'U':
pvoie->recliste.type = 'P';
pvoie->recliste.status = 'N';
break;
case 'X':
pvoie->recliste.status = 'X';
break;
case 'Y':
pvoie->recliste.status = 'Y';
break;
case '$':
pvoie->recliste.status = '$';
break;
case '<':
if (teste_espace ())
{
indd += copy_word(pvoie->recliste.exp, indd, 6);
}
else
{
texte (T_ERR + 2);
ok = 0;
}
break;
case '>':
if (teste_espace ())
{
indd += copy_word(pvoie->recliste.dest, indd, 6);
}
else
{
texte (T_ERR + 2);
ok = 0;
}
break;
case '@':
if (teste_espace ())
{
indd += copy_word(pvoie->recliste.bbs, indd, 6);
}
else
{
strcpy (pvoie->recliste.bbs, "-");
}
break;
case 'R':
pvoie->reverse = 1;
case ' ':
teste_espace ();
if (*indd == '\0')
{
pvoie->recliste.l = TRUE;
pvoie->recliste.debut = pvoie->finf.lastmes + 1;
pvoie->l_mess = nomess;
break;
}
if (strchr (indd, '-'))
{
if (isdigit (*indd))
pvoie->recliste.debut = lit_chiffre (1);
else
{
texte (T_ERR + 3);
ok = 0;
break;
}
++indd;
if (isdigit (*indd))
pvoie->recliste.fin = lit_chiffre (1);
if (pvoie->recliste.fin <= pvoie->recliste.debut)
ok = 0;
}
else
{
if (isdigit (*indd))
pvoie->recliste.fin = pvoie->recliste.debut = lit_chiffre (1);
else
ok = 0;
}
break;
default:
if (isdigit (cmd))
{
list_mine (cmd);
ok = 0;
}
else
{
/*
sprintf(varx[0], "L%c", c) ;
texte(T_ERR + 1) ;
*/
ok = 3;
}
break;
}
return ok;
}
int mbl_lx (void)
{
char c;
int ok = 1;
int i;
bloc_mess *temp;
long numero;
pvoie->reverse = 0;
init_recliste (voiecur);
if (!ISPRINT (*indd))
{
pvoie->recliste.debut = pvoie->finf.lastmes + 1;
pvoie->l_mess = nomess;
}
else
{
sup_ln (indd);
fbb_log (voiecur, 'M', strupr (indd - 1));
c = *indd++;
for (;;)
{
ok = cmd_list(c);
if (ok == 0)
break;
while_space();
c = *indd++;
if (c == '\0')
break;
if (c != '&')
{
ok = 3;
break;
}
incindd();
c = *indd++;
if (c != 'L' && c != 'l')
{
ok = 3;
break;
}
c = *indd++;
}
}
if (ok == 1)
{
if (pvoie->reverse)
{
temp = tete_dir;
numero = pvoie->recliste.debut;
while (temp->suiv)
{
if (temp->suiv->st_mess[0].nmess > numero)
break;
temp = temp->suiv;
}
for (i = 0; i < T_BLOC_MESS; i++)
{
if (temp->st_mess[i].nmess == 0)
{
--i;
break;
}
if (temp->st_mess[i].nmess >= numero)
break;
}
if (i == T_BLOC_MESS)
--i;
pvoie->recliste.ptemp = temp;
pvoie->recliste.offset = i;
}
else
{
pvoie->recliste.ptemp = last_dir ();
pvoie->recliste.offset = T_BLOC_MESS;
}
pvoie->temp1 = 1;
}
return (ok);
}
void list_read (int verbose)
{
long no;
bullist *pbul;
rd_list *ptemp = NULL;
libere_tread (voiecur);
while ((no = lit_chiffre (1)) != 0L)
{
if ((pbul = ch_record (NULL, no, 'Y')) != NULL)
{
if (droit_ok (pbul, 1))
{
if (ptemp)
{
ptemp->suite = (rd_list *) m_alloue (sizeof (rd_list));
ptemp = ptemp->suite;
}
else
{
pvoie->t_read = ptemp = (rd_list *) m_alloue (sizeof (rd_list));
}
ptemp->suite = NULL;
ptemp->nmess = no;
ptemp->verb = verbose;
}
else
texte (T_ERR + 10);
}
else
texte (T_ERR + 10);
}
}
int mbl_list (void)
{
int mode_list = 1;
int verbose = 0;
int error = 0;
switch (pvoie->niv3)
{
case 0:
if (toupper (*indd) == 'C')
{
return (list_lc ());
}
switch (mbl_lx ())
{
case 0:
retour_mbl ();
case 2:
mode_list = 0;
break;
case 1:
pvoie->temp2 = pvoie->lignes;
ch_niv3 (1);
break;
case 3:
mode_list = 0;
error = 1;
--indd;
break;
}
break;
case 1:
break;
case 2:
while_space ();
switch (toupper (*indd))
{
case 'A':
mode_list = 0;
retour_mbl ();
break;
case 'V':
verbose = 1;
case 'R':
mode_list = 0;
incindd ();
if (isdigit (*indd))
{
pvoie->aut_nc = 1;
list_read (verbose);
pvoie->sr_mem = 1;
if (mbl_mess_read () == 0)
{
pvoie->sr_mem = 0;
texte (T_QST + 6);
}
}
else
{
texte (T_ERR + 3);
texte (T_QST + 6);
}
break;
default:
pvoie->temp2 = pvoie->lignes;
ch_niv3 (1);
break;
}
break;
case 3:
mode_list = 0;
pvoie->aut_nc = 1;
if (read_mess (1) == 0)
ch_niv3 (4);
break;
case 4:
mode_list = 0;
pvoie->aut_nc = 1;
pvoie->sr_mem = 1;
if (mbl_mess_read () == 0)
{
pvoie->sr_mem = 0;
texte (T_QST + 6);
ch_niv3 (2);
}
break;
default:
fbb_error (ERR_NIVEAU, "MSG-LIST", pvoie->niv3);
}
if (mode_list)
{
pvoie->lignes = -1;
switch (mbl_bloc_liste ())
{
case 0:
break;
case 1:
retour_mbl ();
break;
case 2:
texte (T_QST + 6);
ch_niv3 (2);
break;
}
}
return (error);
}
/* Test du password */
void mbl_passwd (void)
{
char buffer[80];
switch (pvoie->niv3)
{
case 0:
snd_passwd (buffer);
if (*buffer == '\0')
retour_mbl ();
else
{
outln (buffer, strlen (buffer));
ch_niv3 (1);
}
break;
case 1:
if (tst_passwd (indd))
{
outln ("Ok", 2);
change_droits (voiecur);
sprintf (buffer, "SYS OK");
}
else
{
*pvoie->passwd = '\0';
sprintf (buffer, "SYS FAILED");
}
fbb_log (voiecur, 'M', buffer);
retour_mbl ();
break;
}
}
/* Commande 'S' -> Send messages */
int mbl_send (void)
{
int error = 0;
switch (toupper (*indd))
{
case 'X':
if (!read_only ())
{
--indd;
maj_niv (N_XFWD, 1, 0);
xfwd ();
}
else
retour_mbl ();
break;
case 'Y':
if ((toupper (indd[1]) == 'S') && (!pvoie->read_only) && (droits (CMDSYS)))
{
maj_niv (N_MBL, 14, 0);
mbl_passwd ();
}
else
{
error = 1;
/* cmd_err(--indd) ; */
}
break;
case 'R':
if (!read_only ())
{
*indd = toupper (*indd);
send_reply ();
}
else
retour_mbl ();
break;
case 'C':
if (!read_only ())
{
fbb_log (voiecur, 'S', strupr (indd));
send_copy ();
}
else
retour_mbl ();
break;
default:
maj_niv (N_FORW, 0, 0);
error = fwd ();
break;
}
return (error);
}
/* Commande 'I' -> Info */
void mbl_info (void)
{
char buffer[257];
sprintf (buffer, "LANG\\%s.INF", nomlang + nlang * LG_LANG);
if (!outfich (c_disque (buffer)))
q_mark ();
}
fbb-7.0.11/src/mbl_edit.c 0000664 0001750 0001750 00000046056 13613525371 012007 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
#include
/*
* Module MBL_EDIT.C
*/
static void ch_home (ind_noeud *, info *);
static void ch_password (ind_noeud *, info *);
static void ch_prenom (ind_noeud *, info *);
static void ch_private (ind_noeud *, info *);
static void ch_zip (ind_noeud *, info *);
static void header_edit (void);
static void modif_header (void);
static void modif_user (info *);
static void user_edit (void);
static void option_edit (void);
static char *lit_ind (char *);
static int lit_prenom (void);
static int lit_homebbs (void);
static int lit_locator (void);
static int lit_zip (void);
#include "aff_stat.c"
int mbl_edit (void)
{
int error = 0;
if (pvoie->niv3 == 0)
{
switch (toupper (*indd))
{
case ' ':
ch_niv3 (20);
pvoie->typlist = 0;
header_edit ();
break;
case 'O':
ch_niv3 (40);
option_edit ();
break;
case 'U':
ch_niv3 (0);
user_edit ();
break;
case 'M':
if (voiecur == CONSOLE)
{
++indd;
if ((teste_espace ()) && (*indd) && (*indd == '#' || isdigit (*indd)))
{
if ((pvoie->nmess = lit_chiffre (1)) != 0L)
{
if (ch_record (ptmes, pvoie->nmess, '\0'))
{
reply = 4;
pvoie->enrcur = pvoie->nmess;
#ifdef __WINDOWS__
if (win_edit () == 5)
end_win_edit ();
error = 0;
#endif
#ifdef __linux__
error = 1;
#endif
#ifdef __FBBDOS__
if (mini_edit () == 5)
end_mini_edit ();
error = 0;
#endif
break;
}
else
{
ptmes->numero = pvoie->nmess;
texte (T_ERR + 10);
}
}
else
texte (T_ERR + 3);
}
else
texte (T_ERR + 3);
retour_mbl ();
}
else
error = 1;
break;
default:
/*
varx[0][0] = 'E' ;
strn_cpy(79, varx[0] + 1, indd) ;
texte(T_ERR + 1) ;
retour_mbl() ;
*/
error = 1;
break;
}
}
else
{
if (*indd)
indd[strlen (indd) - 1] = '\0';
switch (pvoie->niv3 / 20)
{
case 0:
user_edit ();
break;
case 1:
header_edit ();
break;
case 2:
option_edit ();
break;
}
}
return (error);
}
static void option_display(void)
{
char buf[80];
int i;
i = sprintf(buf, "System Options : ");
buf[i++] = (bip) ? 'B' : '.';
buf[i++] = (gate) ? 'G' : '.';
buf[i++] = (sed) ? 'M' : '.';
buf[i++] = (ok_tell) ? 'T' : '.';
buf[i++] = (aff_inexport) ? 'X' : '.';
buf[i++] = (aff_popsmtp) ? 'P' : '.';
buf[i] = '\0';
outln(buf, strlen(buf));
sprintf(buf, "(B)eep, (T)alk, (G)ateway, (M)sgEdit, e(X)port, (P)opSmtp : ");
out(buf, strlen(buf));
}
static void option_edit (void)
{
int ok;
switch (pvoie->niv3)
{
case 40:
option_display();
ch_niv3 (41);
break;
case 41:
if (*indd)
{
ok = 1;
if (islower(*indd))
*indd = toupper(*indd);
switch (*indd)
{
case 'B' :
bip = !bip;
break;
case 'G' :
gate = !gate;
break;
case 'M' :
sed = !sed;
break;
case 'T' :
ok_tell = !ok_tell;
break;
case 'X' :
aff_inexport = !aff_inexport;
break;
case 'P' :
aff_popsmtp = !aff_popsmtp;
break;
default :
texte (T_ERR + 0);
ok = 0;
break;
}
if (ok)
maj_options();
option_display();
}
else
retour_mbl ();
break;
}
}
static void header_edit (void)
{
switch (pvoie->niv3)
{
case 20:
if ((teste_espace ()) && (*indd) && (*indd == '#' || isdigit (*indd)))
{
if ((pvoie->nmess = lit_chiffre (1)) != 0L)
{
if (ch_record (ptmes, pvoie->nmess, '\0'))
{
entete_liste ();
aff_status (ptmes);
texte (T_MBL + 39);
texte (T_MBL + 27);
ch_niv3 (21);
break;
}
else
{
ptmes->numero = pvoie->nmess;
texte (T_ERR + 10);
}
}
else
texte (T_ERR + 3);
}
else
texte (T_ERR + 3);
retour_mbl ();
break;
case 21:
if (*indd)
{
modif_header ();
entete_liste ();
aff_status (ptmes);
texte (T_MBL + 39);
texte (T_MBL + 27);
}
else
retour_mbl ();
break;
}
}
static void modif_header (void)
{
char c;
int i;
char *sptr;
unsigned num_indic;
ind_noeud *noeud;
while_space ();
c = toupper (*indd);
incindd ();
switch (c)
{
case 'T': /* Desti */
if ((sptr = lit_ind (indd)) != NULL)
{
noeud = insnoeud (ptmes->desti, &num_indic);
if (ptmes->status == 'N')
--(noeud->nbnew);
--(noeud->nbmess);
strcpy (ptmes->desti, sptr);
ptmes->status = 'N';
maj_rec (pvoie->nmess, ptmes);
num_indic = insarbre (ptmes);
chg_mess (num_indic, ptmes->numero);
ins_iliste (ptmes);
}
else
texte (T_ERR + 0);
break;
case 'V': /* Via */
if (*indd)
{
if (*indd == '.')
*ptmes->bbsv = '\0';
else
strn_cpy (39, ptmes->bbsv, indd);
clear_fwd (ptmes->numero);
for (i = 0; i < NBMASK; i++)
{
ptmes->forw[i] = ptmes->fbbs[i] = '\0';
}
if (ptmes->type == 'B')
ptmes->status = '$';
else
{
if (ptmes->status != 'N')
{
/* increment counter of new messages */
noeud = insnoeud (ptmes->desti, &num_indic);
++(noeud->nbnew);
aff_msg_cons ();
}
ptmes->status = 'N';
}
if (*ptmes->bbsv)
{
swapp_bbs (ptmes);
if (cherche_route (ptmes))
{
texte (T_MBL + 41);
}
if (test_forward (1))
ins_fwd (ptmes);
cr ();
}
maj_rec (pvoie->nmess, ptmes);
}
break;
case 'F': /* Exped */
if (*indd)
{
if ((sptr = lit_ind (indd)) != NULL)
{
strcpy (ptmes->exped, sptr);
maj_rec (pvoie->nmess, ptmes);
}
else
texte (T_ERR + 0);
}
break;
case 'I': /* Titre */
if (*indd)
{
n_cpy (60, ptmes->titre, indd);
maj_rec (pvoie->nmess, ptmes);
}
break;
case 'Y': /* Type */
if (*indd)
{
*indd = toupper (*indd);
if (*indd == 'A' || *indd == 'B' || *indd == 'P' || *indd == 'T')
{
ptmes->type = *indd;
maj_rec (pvoie->nmess, ptmes);
}
else
texte (T_ERR + 0);
}
break;
case 'B': /* Bid */
if (*indd)
{
strn_cpy (12, ptmes->bid, indd);
maj_rec (pvoie->nmess, ptmes);
}
break;
case 'S': /* Status */
if (*indd)
{
*indd = toupper (*indd);
noeud = insnoeud (ptmes->desti, &num_indic);
if ((ptmes->status == 'N') && (*indd != 'N'))
{
--(noeud->nbnew);
}
else if ((ptmes->status != 'N') && (*indd == 'N'))
{
++(noeud->nbnew);
}
if ((ptmes->status != 'A') && (ptmes->status != 'K') &&
((*indd == 'A') || (*indd == 'K')))
{
--(noeud->nbmess);
chg_mess (0xffff, ptmes->numero);
}
else if (((ptmes->status == 'A') || (ptmes->status == 'K')) &&
(*indd != 'A') && (*indd != 'K'))
{
++(noeud->nbmess);
chg_mess (num_indic, ptmes->numero);
}
if (*indd == 'Y' || *indd == 'F' || *indd == 'N' || *indd == '$' || *indd == 'K' || *indd == 'A')
{
ptmes->status = *indd;
/*
if (ptmes->status == 'H') {
for (i = 0 ; i < NBMASK ; i++)
ptmes->fbbs[i] = '\0';
}
*/
maj_rec (pvoie->nmess, ptmes);
aff_msg_cons ();
}
else
texte (T_ERR + 0);
}
break;
default: /* Erreur */
texte (T_ERR + 0);
break;
}
}
void ch_info (void)
{
FILE *fptr;
unsigned r = pvoie->ncur->coord;
if (r == 0xffff)
dump_core ();
fptr = ouvre_nomenc ();
fseek (fptr, ((long) r) * ((long) sizeof (info)), 0);
fwrite ((char *) &(pvoie->finf), (int) sizeof (info), 1, fptr);
ferme (fptr, 19);
}
static char *lit_ind (char *indic)
{
while ((*indic) && (!ISGRAPH (*indic)))
++indic;
strupr (indic);
if (strlen (indic) > 6)
return (NULL);
return (indic);
}
int tstqra (qra)
char *qra;
{
if (strlen (qra) == 6)
return (isalpha (qra[0]) && isalpha (qra[1]) &&
isdigit (qra[2]) && isdigit (qra[3]) &&
isalpha (qra[4]) && isalpha (qra[5]));
else
return (0);
}
static int lit_locator (void)
{
char s[80];
if (ISGRAPH (*indd))
{
strupr (epure (s, 6));
if ((*s == '.') || tstqra (s))
{
if (*s == '.')
{
s[0] = '?';
s[1] = '\0';
}
strcpy (pvoie->finf.qra, s);
return (2);
}
else
{
texte (T_NOM + 14);
}
}
return (1);
}
static int lit_zip (void)
{
char s[80];
if (ISGRAPH (*indd))
{
strupr (epure (s, 8));
if (*s == '.')
*s = '\0';
strcpy (pvoie->finf.zip, s);
user_wp (&pvoie->finf);
/* pvoie->wp = 1; */
return (2);
}
return (1);
}
static int lit_qth (void)
{
char s[80];
if (ISGRAPH (*indd))
{
epure (s, 30);
if (*s == '.')
*s = '\0';
strcpy (pvoie->finf.ville, s);
user_wp (&pvoie->finf);
/* pvoie->wp = 1; */
return (2);
}
return (1);
}
static int lit_homebbs (void)
{
char s[80];
char temp[80];
char *ptr;
if (ISGRAPH (*indd))
{
strupr (epure (s, 40));
if (*s == '.')
*s = '\0';
/* Seul l'indicatif est enregistre */
ptr = strchr (s, '.');
if (ptr)
*ptr = '\0';
/* Pas de SSID */
ptr = strchr (s, '-');
if (ptr)
*ptr = '\0';
strcpy (temp, s);
if (find (temp))
{
/* Seul l'indicatif est enregistre */
strcpy (pvoie->finf.home, s);
user_wp (&pvoie->finf);
/* pvoie->wp = 1; */
return (2);
}
else
texte (T_ERR + 7);
}
return (1);
}
static int lit_prenom (void)
{
info frec;
if (ISGRAPH (*indd))
{
ch_prenom (pvoie->ncur, &frec);
strcpy (pvoie->finf.prenom, frec.prenom);
return (2);
}
return (1);
}
int mbl_name (void)
{
int modif = 0;
int error = 0;
switch (pvoie->niv3)
{
case 0:
if (toupper (*indd) == 'P')
{
int p = no_port (voiecur);
if ((p_port[p].typort == TYP_MOD) || (p_port[p].typort == TYP_TCP))
{
if (read_only ())
{
modif = 1;
break;
}
out ("Enter old password :", 20);
maj_niv (N_MOD, 3, 0);
}
else
error = 1;
}
else if (toupper (*indd) == 'L')
{
if (read_only ())
{
modif = 1;
break;
}
++indd;
if (teste_rep (sup_ln (indd)))
{
incindd ();
modif = lit_locator ();
}
else
{
texte (T_NOM + 11);
ch_niv3 (2);
}
}
else if (toupper (*indd) == 'Q')
{
if (read_only ())
{
modif = 1;
break;
}
++indd;
if (teste_rep (sup_ln (indd)))
{
incindd ();
modif = lit_qth ();
}
else
{
texte (T_NOM + 8);
ch_niv3 (5);
}
}
else if (toupper (*indd) == 'Z')
{
if (read_only ())
{
modif = 1;
break;
}
++indd;
if (teste_rep (sup_ln (indd)))
{
incindd ();
modif = lit_zip ();
}
else
{
texte (T_MBL + 54);
ch_niv3 (3);
}
}
else if (toupper (*indd) == 'H')
{
if (read_only ())
{
modif = 1;
break;
}
++indd;
if (teste_rep (sup_ln (indd)))
{
incindd ();
modif = lit_homebbs ();
}
else
{
texte (T_MBL + 53);
ch_niv3 (4);
}
}
else if (!ISGRAPH (*indd))
{
if (read_only ())
{
modif = 1;
break;
}
if (teste_rep (sup_ln (indd)))
{
incindd ();
modif = lit_prenom ();
}
else
{
texte (T_MBL + 9);
ch_niv3 (1);
}
}
else
error = 1;
break;
case 1:
modif = lit_prenom ();
break;
case 2:
modif = lit_locator ();
break;
case 3:
modif = lit_zip ();
break;
case 4:
modif = lit_homebbs ();
break;
case 5:
modif = lit_qth ();
break;
}
if (modif)
{
if (modif == 2)
{
ch_info ();
texte (T_MBL + 10);
}
retour_mbl ();
}
return (error);
}
static void ch_private (ind_noeud * noeud, info * frec)
{
FILE *fptr;
fptr = ouvre_nomenc ();
if (noeud->coord == 0xffff)
dump_core ();
fseek (fptr, ((long) noeud->coord * sizeof (info)), 0);
fread (frec, sizeof (info), 1, fptr);
/* strupr (indd); */
if (!iscntrl (*indd))
{
if (*indd == '.')
*indd = '\0';
epure (frec->priv, 12);
fseek (fptr, ((long) noeud->coord * sizeof (info)), 0);
fwrite (frec, sizeof (info), 1, fptr);
}
ferme (fptr, 36);
}
static void ch_home (ind_noeud * noeud, info * frec)
{
char *ptr;
char temp[80];
FILE *fptr;
if (noeud->coord == 0xffff)
dump_core ();
fptr = ouvre_nomenc ();
fseek (fptr, ((long) noeud->coord * sizeof (info)), 0);
fread (frec, sizeof (info), 1, fptr);
if (!iscntrl (*indd))
{
strupr (indd);
if (*indd == '.')
*indd = '\0';
ptr = strchr (indd, '.');
if (ptr)
*ptr = '\0';
ptr = strchr (indd, '-');
if (ptr)
*ptr = '\0';
strn_cpy (40, temp, indd);
if (find (temp))
{
epure (frec->home, 40);
fseek (fptr, ((long) noeud->coord * sizeof (info)), 0);
fwrite (frec, sizeof (info), 1, fptr);
user_wp (frec);
/* pvoie->wp = 1; */
}
else
texte (T_ERR + 7);
}
ferme (fptr, 36);
}
static void ch_zip (ind_noeud * noeud, info * frec)
{
FILE *fptr;
char *scan;
if (noeud->coord == 0xffff)
dump_core ();
fptr = ouvre_nomenc ();
fseek (fptr, ((long) noeud->coord * sizeof (info)), 0);
fread (frec, sizeof (info), 1, fptr);
strupr (indd);
if (!iscntrl (*indd))
{
if (*indd == '.')
*indd = '\0';
epure (frec->zip, 8);
scan = frec->zip;
while (*scan)
{
if (*scan == ' ')
*scan = '-';
++scan;
}
fseek (fptr, ((long) noeud->coord * sizeof (info)), 0);
fwrite (frec, sizeof (info), 1, fptr);
user_wp (frec);
/* pvoie->wp = 1; */
}
ferme (fptr, 36);
}
static void ch_password (ind_noeud * noeud, info * frec)
{
FILE *fptr;
if (noeud->coord == 0xffff)
dump_core ();
fptr = ouvre_nomenc ();
fseek (fptr, ((long) noeud->coord * sizeof (info)), 0);
fread (frec, sizeof (info), 1, fptr);
strupr (indd);
if (!iscntrl (*indd))
{
if (*indd == '.')
*indd = '\0';
epure (frec->pass, 12);
fseek (fptr, ((long) noeud->coord * sizeof (info)), 0);
fwrite (frec, sizeof (info), 1, fptr);
}
ferme (fptr, 36);
}
static void ch_prenom (ind_noeud * noeud, info * frec)
{
FILE *fptr;
char *scan;
if (noeud->coord == 0xffff)
dump_core ();
fptr = ouvre_nomenc ();
fseek (fptr, ((long) noeud->coord * sizeof (info)), 0);
fread (frec, sizeof (info), 1, fptr);
if (!iscntrl (*indd))
{
if (*indd == '.')
*indd = '\0';
epure (frec->prenom, 12);
scan = frec->prenom;
while (*scan)
{
if (*scan == ' ')
*scan = '-';
++scan;
}
fseek (fptr, ((long) noeud->coord * sizeof (info)), 0);
fwrite (frec, sizeof (info), 1, fptr);
user_wp (frec);
/* pvoie->wp = 1; */
}
ferme (fptr, 36);
}
static void user_edit (void)
{
int voie;
char s[80];
char *ind, *ptr;
indicat indic;
unsigned num_indic;
FILE *fptr;
info frec;
sup_ln (indd);
switch (pvoie->niv3)
{
case 0:
++indd;
if ((teste_espace ()) && (*indd) && find (indd))
{
/*
if (num_voie(indd) != -1) {
texte(T_MBL + 24) ;
retour_mbl() ;
break ;
}
*/
pvoie->emis = insnoeud (indd, &num_indic);
if (pvoie->emis->coord == 0xffff)
{
var_cpy (0, indd);
texte (T_MBL + 29);
}
else
{
fptr = ouvre_nomenc ();
fseek (fptr, (long) pvoie->emis->coord * sizeof (frec), 0);
fread (&frec, sizeof (info), 1, fptr);
ferme (fptr, 39);
texte (T_MBL + 11);
affiche_user (&frec, 1);
var_cpy (0, indd);
texte (T_MBL + 30);
}
ch_niv3 (1);
break;
}
else
texte (T_ERR + 7);
retour_mbl ();
break;
case 1:
if (toupper (*indd) == Oui)
{
if (pvoie->emis->coord == 0xffff)
{
pvoie->emis->coord = rinfo++;
/* cprintf("Rinfo : %ld\r\n", rinfo) ; */
ind = s;
ptr = pvoie->emis->indic;
pvoie->emis->val = 1;
/*
*ind++ = *ptr++;
if (pvoie->emis->lettre)
*ind++ = pvoie->emis->lettre ;
*/
while ((*ind++ = *ptr++) != '\0');
indic.num = extind (s, indic.call);
init_info (&frec, &indic);
if (pvoie->emis->coord == 0xffff)
dump_core ();
fptr = ouvre_nomenc ();
fseek (fptr, (long) pvoie->emis->coord * ((long) sizeof (info)), 0);
fwrite ((char *) &frec, (int) sizeof (info), 1, fptr);
ferme (fptr, 40);
texte (T_MBL + 11);
affiche_user (&frec, 1);
texte (T_MBL + 28);
ch_niv3 (2);
break;
}
else
{
if (pvoie->emis->coord == 0xffff)
dump_core ();
fptr = ouvre_nomenc ();
fseek (fptr, (long) pvoie->emis->coord * ((long) sizeof (info)), 0);
fread ((char *) &frec, sizeof (info), 1, fptr);
*(frec.indic.call) = '\0';
fseek (fptr, (long) pvoie->emis->coord * ((long) sizeof (info)), 0);
fwrite ((char *) &frec, (int) sizeof (info), 1, fptr);
ferme (fptr, 41);
pvoie->emis->coord = 0xffff;
retour_mbl ();
}
}
else
{
if (pvoie->emis->coord == 0xffff)
retour_mbl ();
else
{
texte (T_MBL + 28);
ch_niv3 (2);
}
}
break;
case 2:
if (*indd)
{
fptr = ouvre_nomenc ();
fseek (fptr, (long) pvoie->emis->coord * sizeof (frec), 0);
fread (&frec, sizeof (info), 1, fptr);
ferme (fptr, 39);
modif_user (&frec);
texte (T_MBL + 11);
affiche_user (&frec, 1);
texte (T_MBL + 28);
for (voie = 0; voie < NBVOIES; ++voie)
{
if (svoie[voie]->sta.connect &&
indcmp (svoie[voie]->sta.indicatif.call, frec.indic.call))
{
svoie[voie]->finf = frec;
}
}
}
else
retour_mbl ();
break;
}
}
static void modif_user (info * frec)
{
char c;
while_space ();
c = toupper (*indd);
incindd ();
switch (c)
{
case 'B':
ch_bit (pvoie->emis, frec, F_BBS, '\0');
break;
case 'E':
ch_bit (pvoie->emis, frec, F_EXC, '\0');
break;
case 'G':
if (isdigit (*indd))
{
ch_language (atoi (indd), pvoie->emis, frec);
}
break;
case 'F':
ch_bit (pvoie->emis, frec, F_PMS, '\0');
break;
case 'H':
ch_home (pvoie->emis, frec);
break;
case 'I':
ch_bit (pvoie->emis, frec, F_NEW, '\0');
break;
case 'L':
ch_bit (pvoie->emis, frec, F_LOC, '\0');
break;
case 'M':
ch_bit (pvoie->emis, frec, F_MOD, '\0');
break;
case 'N':
ch_prenom (pvoie->emis, frec);
break;
case 'P':
ch_bit (pvoie->emis, frec, F_PAG, '\0');
break;
case 'R':
ch_bit (pvoie->emis, frec, F_PRV, '\0');
break;
case 'S':
ch_bit (pvoie->emis, frec, F_SYS, '\0');
break;
case 'U':
ch_bit (pvoie->emis, frec, F_UNP, '\0');
break;
case 'V':
ch_private (pvoie->emis, frec);
break;
case 'W':
ch_password (pvoie->emis, frec);
break;
case 'X':
ch_bit (pvoie->emis, frec, F_EXP, '\0');
break;
case 'Z':
ch_zip (pvoie->emis, frec);
break;
default: /* Erreur */
texte (T_ERR + 0);
break;
}
}
void maj_rec (long nomess, bullist * pbul)
{
mess_noeud *mptr = findmess (nomess);
if (mptr)
{
ouvre_dir ();
/********* Test overflow **********
if ((long) mptr->noenr > maxrec) exit_prg(-1901);
********** Fin du test ***********/
write_dir (mptr->noenr, pbul);
ferme_dir ();
}
}
fbb-7.0.11/src/rx25.c 0000664 0001750 0001750 00000024316 13613525371 011023 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
/*
* RX25.C : Decodage de trames au format ROSE X25
*
* D'apres KD.BAS de F1EBN
*
* FC1OAT@F6ABJ - 920820
*/
#include
/******************************************************************************
* Dump ASCII avec Filtrage des caracteres non affichables
******************************************************************************/
static int decode_x25 (uchar *, int, char *);
static void decode_X121 (uchar *, int, char *);
static void decode_digi (uchar *, int, char *);
static void dump_hexa (uchar *, int, char *);
void put_rose (uchar * texte, int attr, int nbcar)
{
uchar chaine[400];
uchar *ptr = chaine;
int decode = 1; /* A patcher, au cas ou ... */
if (decode)
{
if (nbcar > 256)
nbcar = 256;
strcpy (ptr, "X25 : ");
ptr += 6;
nbcar = 6 + decode_x25 (texte, nbcar, ptr);
}
else
memcpy (chaine, texte, nbcar);
put_ui (chaine, attr, nbcar);
}
/******************************************************************************
* Les Causes
*****************************************************************************/
static char *ResetCause (int cause)
{
static char hex_cause[3];
/* From ISO 8208 page 48 */
switch (cause)
{
case 0:
return "DTE Originated";
case 0xC1:
return "Gateway-detected Procedure Error";
case 0xC3:
return "Gateway Congestion";
case 0xC7:
return "Gateway Operational";
default:
switch (cause & 0x7F)
{
case 0x01:
return "Out Of Order";
case 0x03:
return "Remote Procedure Error";
case 0x05:
return "Local Procedure Error";
case 0x07:
return "Network Congestion";
case 0x09:
return "Remote DTE Operational";
case 0x0F:
return "Network Operational";
case 0x11:
return "Incompatible Destination";
case 0x1D:
return "Network Out Of Order";
default:
sprintf (hex_cause, "%2.2X", cause);
return hex_cause;
}
}
}
static char *ClearCause (int cause)
{
static char hex_cause[3];
/* From ISO 8208 page 43 */
switch (cause)
{
case 0:
return "DTE Originated";
case 0xC1:
return "Gateway-detected Procedure Error";
case 0xC3:
return "Gateway Congestion";
case 0xC7:
return "Gateway Operational";
default:
switch (cause & 0x7F)
{
case 0x01:
return "Number Busy";
case 0x09:
return "Out Of Order";
case 0x11:
return "Remote Procedure Error";
case 0x19:
return "Reverse Charging Acceptance Not Subscribed";
case 0x21:
return "Incompatible Destination";
case 0x29:
return "Fast Select Acceptance Not Subscribed";
case 0x39:
return "Ship Absent";
case 0x03:
return "Invalid Facility Requested";
case 0x0B:
return "Access Barred";
case 0x13:
return "Local Procedure Error";
case 0x05:
return "Network Congestion";
case 0x0D:
return "Not Obtainable";
case 0x15:
return "RPOA Out Of Order";
default:
sprintf (hex_cause, "%2.2X", cause);
return hex_cause;
}
}
}
static char *RestartCause (int cause)
{
static char hex_cause[3];
/* From ISO 8208 page 50 */
switch (cause)
{
case 0:
return "DTE Originated";
case 1:
return "Local Procedure Error";
case 3:
return "Network Congestion";
case 7:
return "Network Operational";
case 0x7F:
return "Registration/Cancellation Confirmed";
default:
sprintf (hex_cause, "%2.2X", cause);
return hex_cause;
}
}
/******************************************************************************
* Decodage de trames X25
*****************************************************************************/
/* Decodage d'une adresse X.121 */
static void decode_X121 (uchar * data, int lgaddr, char *result)
{
char bcd;
int pfo, pfa;
while (lgaddr > 0)
{
pfo = (*data & 0xF0) >> 4;
pfa = *data & 0x0F;
bcd = pfo + '0';
*result++ = bcd;
if (--lgaddr == 0)
break;
bcd = pfa + '0';
*result++ = bcd;
lgaddr--;
data++;
}
*result = '\0';
}
/* Dump Hexa */
static void dump_hexa (uchar * data, int l_data, char *result)
{
int i;
i = 0;
while (l_data-- > 0)
{
sprintf (result, "%2.2X ", *data++);
result += 3;
if (++i == 16)
{
*result++ = '\r';
i = 0;
}
}
*result = '\0';
}
static char *rs_addr(char *addr)
{
static char str[20];
strncpy(str, addr, 4);
str[4] = ',';
strncpy(str+5, addr+4, 6);
str[11] = '\0';
return str;
}
/* Decodage d'un champ digi */
static void decode_digi (uchar * data, int l_data, char *result)
{
while (l_data-- > 1)
{
*result++ = *data++ >> 1;
}
*result++ = '-';
*result++ = (*data & 0x7F) >> 1;
*result = 0;
}
/* Decodage d'une suite de champs facilite */
static void decodage_facilite (uchar * data, char *result)
{
int lgfac, lg, fct, lgdigi, lgaddcall;
int lgad, lgaddr, lgadind;
static char digis[10], digid[10], icd[10];
static char indorig[10], inddest[10];
static char addstorig[20], addstdest[20];
lgfac = *data++;
lg = lgfac;
digid[0] = digis[0] = '\0';
while (lg > 0)
{
fct = *data++;
lg--;
switch (fct)
{
case 0:
/* Marker=0 National Fac ou Marker=15 CCITT */
data++;
lg--;
break;
case 0x3F:
/* Utilise si appel par call digi au lieu du call N3 */
sprintf (result, "\rFacility 3F%2.2X", *data++);
lg--;
break;
case 0x7F:
/* Nombre aleatoire pour eviter les rebouclages */
sprintf (result, " NbAlea: %2.2X%2.2X",
*data, *(data + 1));
data += 2;
lg -= 2;
break;
case 0xE9:
/* Digi destination */
lgdigi = *data++;
decode_digi (data, lgdigi, digid);
data += lgdigi;
lg -= 1 + lgdigi;
break;
case 0xEB:
/* Digi origine */
lgdigi = *data++;
decode_digi (data, lgdigi, digis);
data += lgdigi;
lg -= 1 + lgdigi;
break;
case 0xC9:
/* Adresse et indicatif du nodal destination */
case 0xCB:
/* Adresse et indicatif du nodal origine */
lgaddcall = *data++;
data++;
dump_hexa (data, 3, icd);
data += 3;
lgad = *data++;
lg -= 6;
lgaddr = lgad;
if (fct == 0xCB)
decode_X121 (data, lgaddr, addstorig);
else
decode_X121 (data, lgaddr, addstdest);
data += (lgad + 1) / 2;
lg -= (lgad + 1) / 2;
lgadind = lgaddcall - (lgad + 1) / 2 - 5;
if (fct == 0xCB)
strncpy (indorig, data, lgadind);
else
strncpy (inddest, data, lgadind);
data += lgadind;
lg -= lgadind;
break;
default:
sprintf (result, "\rUnknown Facility Type %2.2X", fct);
lg = 0;
break;
}
result += strlen (result);
}
sprintf (result, "\r%s@%s", indorig, rs_addr(addstorig));
result += strlen (result);
if (*digis)
sprintf (result, " via %s", digis);
strcat (result, " -> ");
result += strlen (result);
sprintf (result, "%s@%s", inddest, rs_addr(addstdest));
result += strlen (result);
if (*digid)
sprintf (result, " via %s", digid);
}
/* Decodage des donnees accompagnant un CALL REQUEST */
static void decode_call_req (uchar * data, int l_data, char *result)
{
int lgdest, lgorig, lgaddr;
/* Decodage du champ adresse */
lgdest = *(data + 3) & 0x0F;
lgorig = (*(data + 3) & 0xF0) >> 4;
lgaddr = lgorig + lgdest;
/*
decode_X121 (data + 4 + (lgdest / 2), lgorig, result);
strcat (result, " -> ");
decode_X121 (data + 4, lgdest, result + strlen (result));
*/
data += 4 + (lgaddr / 2);
l_data -= 4 + (lgaddr / 2);
/* result += strlen (result); */
/* Decodage des champs facilite */
decodage_facilite (data, result);
}
/* Point d'entree du decodage des trames X25 */
static int decode_x25 (uchar * data, int l_data, char *result)
{
int tpaq, id_format, r, s, lci, lg;
char *ptemp = result;
lci = ((*data & 0x0f) << 4) | *(data + 1);
id_format = *data;
tpaq = *(data + 2);
r = (tpaq & 0xE0) >> 5;
s = (tpaq & 0x0E) >> 1;
sprintf (result, "LCI %03d : ", lci);
result += strlen (result);
if (id_format & 0x80)
strcat (result, "Q ");
if (id_format & 0x40)
strcat (result, "D ");
if (tpaq & 1)
{
switch (tpaq)
{
case 0x0B:
sprintf (result, "CALL REQUEST ");
result += strlen (result);
decode_call_req (data, l_data, result);
break;
case 0x0F:
sprintf (result, "CALL ACCEPTED");
break;
case 0x13:
sprintf (result,
"CLEAR REQUEST - Cause %s - Diag %d",
ClearCause (*(data + 3)), *(data + 4));
break;
case 0x17:
sprintf (result, "CLEAR CONFIRMATION");
break;
case 0x23:
sprintf (result, "INTERRUPT");
break;
case 0x27:
sprintf (result, "INTERRUPT CONFIRMATION");
break;
case 0x1B:
sprintf (result,
"RESET REQUEST - Cause %s - Diag %d",
ResetCause (*(data + 3)), *(data + 4));
break;
case 0x1F:
sprintf (result, "RESET CONFIRMATION");
break;
case 0xF3:
sprintf (result, "REGISTRATION REQUEST");
break;
case 0xF7:
sprintf (result, "REGISTRATION CONFIRMATION");
break;
case 0xFB:
sprintf (result,
"RESTART REQUEST - Cause %s - Diag %d",
RestartCause (*(data + 3)), *(data + 4));
break;
case 0xFF:
sprintf (result, "RESTART CONFIRMATION");
break;
default:
switch (tpaq & 0x0F)
{
case 0x01:
sprintf (result, "RR R%d", r);
break;
case 0x05:
sprintf (result, "RNR R%d", r);
break;
case 0x09:
sprintf (result, "REJ R%d", r);
break;
}
break;
}
l_data = 0;
lg = strlen (ptemp);
}
else
{
l_data -= 3;
if (tpaq & 0x10)
strcat (result, "M ");
sprintf (result, "DATA R%d S%d L=%d", r, s, l_data);
strcat (result, "\r");
lg = strlen (ptemp);
result += strlen (result);
if (l_data < 0)
l_data = 0;
memcpy (result, data + 3, l_data);
}
return (lg + l_data);
}
fbb-7.0.11/src/conf.c 0000664 0001750 0001750 00000012143 13613525371 011143 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
/*
* MODULE CONFERENCE
*/
#include
static void conferenciers (void);
static void send_conf (char *, int);
int conference (void)
{
int c, port, voie;
switch (pvoie->niv2)
{
case 0:
c = toupper (*indd);
switch (c)
{
case 'W':
conferenciers ();
retour_mbl ();
break;
case '\0':
case '\r':
cnf_prec = -1;
text_conf (T_CNF + 3);
pvoie->conf = 1;
texte (T_CNF + 0);
conferenciers ();
ch_niv2 (1);
break;
default:
return (1);
/*
sprintf(varx[0], "C%c", c) ;
texte(T_ERR + 1) ;
retour_mbl() ;
*/
/* break ; */
}
break;
case 1:
if (*indd == '.')
{
switch (toupper (*(indd + 1)))
{
case 'Q':
pvoie->conf = 0;
texte (T_CNF + 4);
text_conf (T_CNF + 5);
retour_mbl ();
break;
case 'W':
conferenciers ();
break;
case 'D':
indd += 2;
if (teste_espace ())
{
sup_ln (strupr (indd));
if (((voie = num_voie (indd)) != -1) &&
(svoie[voie]->conf))
{
deconnexion (voie, 1);
}
else
{
var_cpy (0, indd);
texte (T_CNF + 10);
}
}
break;
case 'C':
indd += 2;
while_space ();
if ((isdigit (*indd)) && (isspace (*(indd + 1))))
{
port = *indd - '0';
++indd;
}
else
port = no_port (voiecur);
if ((port > 0) &&
(port < NBPORT) &&
((p_port[port].moport & 0x10) || (droits (ACCGATE))) &&
(p_port[port].pvalid))
{
if ((p_port[port].typort == TYP_BPQ) ||
(p_port[port].typort == TYP_MOD) ||
(p_port[port].typort == TYP_TCP))
{
texte (T_ERR + 14);
break;
}
if (teste_espace ())
{
if ((voie = ch_voie (port, 0)) > 0)
{
/* save_voie = voiecur ; */
sup_ln (indd);
indd -= 2;
*indd = 'C';
*(indd + 1) = ' ';
/* cprintf("Envoie <%s>\r\n", indd) ; */
if (connect_station (voie, 1, strupr (indd)) == 0)
{
svoie[voie]->conf = 1;
svoie[voie]->niv1 = N_CONF;
svoie[voie]->niv2 = svoie[voie]->niv3 = 0;
/* cprintf("Met %d sur la voie %d\r\n", N_CONF, voie); */
}
/* selvoie(save_voie) ; */
}
else
texte (T_GAT + 3);
}
else
texte (T_ERR + 2);
}
else
texte (T_GAT + 7);
break;
case 'H':
case '?':
pvoie->niv1 = N_MBL;
out_help ("C");
pvoie->niv1 = N_CONF;
break;
default:
send_conf (indd, nb_trait);
break;
}
}
else
send_conf (indd, nb_trait);
break;
}
return (0);
}
static void conferenciers (void)
{
int voie, vide = 1;
texte (T_CNF + 1);
for (voie = 0; voie < NBVOIES; voie++)
{
if ((svoie[voie]->conf) && (svoie[voie]->sta.connect >= 1))
{
var_cpy (0, svoie[voie]->sta.indicatif.call);
itoa ((voie > 0) ? voie - 1 : voie, varx[1], 10);
texte (T_CNF + 2);
vide = 0;
}
}
if (vide)
texte (T_CNF + 7);
}
char *k_var (void)
{
int voie, vide = 1;
static char buffer[257];
*buffer = '\0';
for (voie = 0; voie < NBVOIES; voie++)
{
if ((svoie[voie]->conf) && (svoie[voie]->sta.connect >= 1))
{
if (!vide)
strcat (buffer, ", ");
strcat (buffer, svoie[voie]->sta.indicatif.call);
vide = 0;
}
}
if (vide)
strcpy (buffer, langue[vlang]->plang[T_CNF + 7 - 1]);
return (buffer);
}
void text_conf (int numero)
{
int save_voie = voiecur;
int voie;
var_cpy (0, pvoie->sta.indicatif.call);
for (voie = 0; voie < NBVOIES; voie++)
{
if ((svoie[voie]->sta.connect) && (voie != save_voie) && (svoie[voie]->conf))
{
selvoie (voie);
texte (numero);
aff_etat ('E');
send_buf (voie);
}
}
selvoie (save_voie);
}
static void send_conf (char *txt_conf, int nbcar)
{
int save_voie = voiecur;
int voie;
for (voie = 0; voie < NBVOIES; voie++)
{
if ((voie != save_voie) && (svoie[voie]->conf))
{
selvoie (voie);
pvoie->lignes = -1;
if (cnf_prec != save_voie)
{
var_cpy (0, svoie[save_voie]->sta.indicatif.call);
texte (T_CNF + 6);
}
out (txt_conf, nbcar);
aff_etat ('E');
send_buf (voie);
}
}
selvoie (save_voie);
cnf_prec = voiecur;
}
fbb-7.0.11/src/fbb_conf.c 0000664 0001750 0001750 00000012454 14136026521 011753 0000000 0000000 /***********************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
***********************************************************************/
#include
#include
#include
#include
#define FBBCONFFILE "/usr/local/etc/ax25/fbb/fbb.conf"
/* Default values for the fbb.conf file */
static char *defstr[] = {
"conf", "/usr/local/etc/ax25/fbb",
"data", "/usr/local/var/ax25/fbb",
"mess", "/usr/local/var/ax25/fbb/mail",
"comp", "/usr/local/var/ax25/fbb/binmail",
"fbbd", "*,*,/usr/local/var/ax25/fbb/fbbdos,*,*,*,*,*",
"yapp", "/usr/local/var/ax25/fbb/fbbdos/yapp",
"docs", "/usr/local/share/doc/fbb",
"sysm", "",
"impo", "/usr/local/var/ax25/fbb/mail/mail.in",
"logs", "OK",
"test", "NO",
"fbbf", "OK 160",
"fbbc", "OK 3",
"aski", "OK",
"mask", "3616",
"secu", "0 4 59",
"warn", "255",
"hous", "2",
"time", "10 20",
"maxd", "0 0",
"loca", "0",
"beac", "8",
"scro", "1500 1500 1500",
"fwdh", "[$c] $$:$R",
"maxb", "30000",
"life", "30",
"wpca", "",
"zipc", "000000",
"unpr", "500 5 P",
"upba", "",
"dwba", "",
"pg", "/usr/local/lib/fbb/pg",
"fdir", "/usr/local/lib/fbb/filter",
"sdir", "/usr/local/lib/fbb/server",
"tdir", "/usr/local/lib/fbb/tool",
"poph", "",
NULL
};
/* a keyword has a maximum of 4 characters */
typedef struct conf_list {
char key[5];
char *value;
struct conf_list *next;
} ConfList;
static ConfList *conf_head = NULL;
/* Creates a list of keyword = value */
int read_fbb_conf(char *pathname)
{
int i;
int len;
FILE *fp;
char *ptr;
char *scan;
char line[256];
ConfList *conf;
if (pathname == NULL)
if ((pathname = getenv("FBBCONF")) == NULL)
pathname = FBBCONFFILE;
if ((fp = fopen (pathname, "r")) == NULL)
return 1;
while (fgets (line, sizeof(line), fp))
{
scan = line;
/* Eats spaces */
while (isspace(*scan))
++scan;
if (*scan == '#' || *scan == '\0')
continue;
/* remove the leading \n */
len = strlen(scan);
if (len && (scan[len-1] == '\n'))
scan[len-1] = '\0';
/* allocate a new structure */
conf = malloc(sizeof(ConfList));
if (conf == NULL)
return 2; /* Not enough memory */
conf->value = NULL;
conf->next = conf_head;
conf_head = conf;
/* extract the keyword */
i = 0;
ptr = conf->key;
while (isgraph(*scan))
{
if (i++ < 4)
{
*ptr++ = *scan;
}
++scan;
if (*scan == '=')
break;
}
*ptr = '\0';
/* finds the '=' */
scan = strchr(scan, '=');
/* Copy the value */
if (scan)
{
++scan;
while (isspace(*scan))
++scan;
/* if the first character is '"' then string ends with '"' */
if (*scan == '"')
{
++scan;
ptr = strrchr(scan, '"');
if (ptr)
*ptr = '\0';
}
conf->value = strdup(scan);
}
else
{
conf->value = strdup("");
}
}
fclose(fp);
return 0;
}
/* returns the value of a keyword. If unknown return NULL */
char *find_fbb_conf(char *key, int next)
{
static ConfList *conf_next = NULL;
ConfList *conf = conf_head;
if (next)
conf = conf_next;
while (conf)
{
if (strncasecmp(key, conf->key, 4) == 0)
{
conf_next = conf->next;
return strdup(conf->value);
}
conf = conf->next;
}
return NULL;
}
/* returns the default value of a keyword. If unknown return NULL */
char *def_fbb_conf(char *key)
{
int pos;
for (pos = 0 ; defstr[pos] ; pos += 2)
{
if (strncasecmp(key, defstr[pos], 4) == 0)
{
return strdup(defstr[pos+1]);
}
}
return NULL;
}
/* free the list of keywords */
void free_fbb_conf(void)
{
ConfList *conf;
while (conf_head)
{
conf = conf_head;
conf_head = conf_head->next;
free(conf->value);
free(conf);
}
}
/* get the list of default values */
char *get_fbb_def(int next)
{
static int pos = 0;
char str[512];
if (next == 0)
pos = 0;
if (defstr[pos])
{
sprintf(str, "%s\t%s", defstr[pos], defstr[pos+1]);
pos += 2;
return strdup(str);
}
return NULL;
}
/* get the list of all values */
char *get_fbb_all(int next)
{
static int first = 1;
static int pos = 0;
static ConfList *conf_next = NULL;
char str[512];
if (first)
{
first = 0;
pos = 0;
conf_next = conf_head;
}
if (next == 0)
{
pos = 0;
conf_next = conf_head;
}
if (conf_next)
{
sprintf(str, "s %s\t%s", conf_next->key, conf_next->value);
conf_next = conf_next->next;
return strdup(str);
}
while (defstr[pos])
{
if (!find_fbb_conf(defstr[pos], 0))
{
sprintf(str, "d %s\t%s", defstr[pos], defstr[pos+1]);
pos += 2;
return strdup(str);
}
else
{
pos += 2;
}
}
return NULL;
}
fbb-7.0.11/src/mbl_user.c 0000664 0001750 0001750 00000025663 13660522330 012033 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
#include
#include
/*
* Module emulation WA7MBL
*/
static void aff_aide (FILE *);
static int user_dump (unsigned);
static int heardcmp (const void *, const void *);
/* Commande ? -> Help */
void help (char *cmd)
{
if (*cmd)
out_help (cmd);
else
{
char str[10];
strcpy (str, "?");
out_help (str);
}
retour_menu (pvoie->niv1);
}
int out_help (char *cmde)
{
char buffer[257];
char str_aide[255];
char *ptr;
char *cmd;
static char qm[2] = "?";
FILE *fptr;
int niveau;
int position;
int aide = FALSE;
char command[80];
n_cpy (78, command, cmde);
cmd = command;
pvoie->aut_nc = 1;
if ((!SYS (pvoie->finf.flags)) && (!LOC (pvoie->finf.flags)) && (P_GUEST (voiecur)))
{
position = -1;
cmd = qm;
}
else
position = pvoie->niv1;
sprintf (buffer, "LANG\\%s.HLP", nomlang + nlang * LG_LANG);
if ((fptr = fopen (c_disque (buffer), "rt")) != NULL)
{
strupr (sup_ln (cmd));
if (ISGRAPH (*cmd))
{
while (fgets (buffer, 256, fptr))
{
if (*buffer == '#')
continue;
if ((buffer[0] == '@') && (buffer[1] == '@'))
{
sscanf (buffer, "%*s %d %s", &niveau, str_aide);
if (niveau == position)
{
for (ptr = strtok (str_aide, "|"); ptr; ptr = strtok (NULL, "|"))
{
if (strncmp (ptr, cmd, 80) == 0)
{
aff_aide (fptr);
aide = TRUE;
break;
}
}
if (aide)
break;
}
}
}
}
ferme (fptr, 35);
}
if ((*cmd) && (!aide))
{
var_cpy (0, cmd);
texte (T_ERR + 5);
}
return (aide);
}
static void aff_aide (FILE * fptr)
{
char buffer[257];
char *ptr;
int nb;
while (fgets (buffer, 256, fptr))
{
if (*buffer == '#')
continue;
nb = 0;
if ((*buffer == '@') && (*(buffer + 1) == '@'))
break;
ptr = buffer;
while (*ptr)
{
if (*ptr == '\n')
*ptr = '\r';
++ptr;
++nb;
}
out (buffer, nb);
}
}
/* Commande D -> DOS ou dump fichiers systeme */
int mbl_dump (void)
{
int erreur = 0;
unsigned masque = 0;
switch (pvoie->niv3)
{
case 0:
if (!ISGRAPH (*indd))
{
sup_ln (indd);
if (*indd)
{ /* Download */
--indd;
pvoie->temp1 = pvoie->niv1;
maj_niv (N_DOS, 2, 0);
send_file (1);
}
else
{ /* DOS */
if (miniserv & 2)
{
maj_niv (N_DOS, 0, 0);
ptmes->date = time (NULL);
pvoie->mbl = 0;
texte (T_DOS + 8);
dos ();
}
else
return (1);
}
return (0);
}
if (droits (COSYSOP))
{
*indd = toupper (*indd);
switch (*indd)
{
case 'B':
masque = F_BBS;
break;
case 'E':
masque = F_EXC;
break;
case 'F':
masque = F_PMS;
break;
case 'L':
masque = F_LOC;
break;
case 'M':
masque = F_MOD;
break;
case 'P':
masque = F_PAG;
break;
case 'S':
masque = F_SYS;
break;
case 'U':
masque = 0xffff;
break;
case 'X':
masque = F_EXP;
break;
default:
erreur = 1;
}
if (!erreur)
{
pvoie->temp2 = 0;
pvoie->temp3 = masque;
pvoie->enrcur = 0L;
incindd ();
strn_cpy (9, pvoie->appendf, sup_ln (indd));
if (user_dump (masque))
ch_niv3 (1);
else
retour_mbl ();
return (0);
}
}
break;
case 1:
if (user_dump (pvoie->temp3) == 0)
{
pvoie->temp3 = 0;
retour_mbl ();
}
return (0);
/*
varx[0][0] = 'D' ;
strn_cpy(79, varx[0] + 1, indd) ;
texte(T_ERR + 1) ;
retour_mbl() ; */
}
return (1);
}
char *strflags (info * frec)
{
#define NB_FLAG 11
int i;
static char flag[NB_FLAG + 1];
for (i = 0; i < NB_FLAG; i++)
flag[i] = '.';
flag[NB_FLAG] = '\0';
if (NEW (frec->flags))
flag[10] = 'I';
if (UNP (frec->flags))
flag[9] = 'U';
if (MOD (frec->flags))
flag[8] = 'M';
if (EXC (frec->flags))
flag[7] = 'E';
if (PMS (frec->flags))
flag[6] = 'F';
if (LOC (frec->flags))
flag[5] = 'L';
if (EXP (frec->flags))
flag[4] = 'X';
if (SYS (frec->flags))
flag[3] = 'S';
if (BBS (frec->flags))
flag[2] = 'B';
if (PAG (frec->flags))
flag[1] = 'P';
if (PRV (frec->flags))
flag[0] = 'R';
return (flag);
}
void affiche_user (info * frec, int mode)
{
char s[200];
char *flag = strflags (frec);
sprintf (s, "%-6s-%-2d %s/%s %5ld %s %-12s %-12s %-12s",
frec->indic.call, frec->indic.num,
date_mbl (frec->hcon), heure_mbl (frec->hcon),
frec->nbcon, flag,
frec->prenom, frec->pass, frec->priv);
outln (s, strlen (s));
if (mode)
{
var_cpy (0, frec->home);
var_cpy (1, frec->zip);
texte (T_MBL + 55);
}
}
static int user_dump (unsigned masque)
{
FILE *fptr;
info frec;
int ind = FALSE;
int retour = 0;
int match;
char w_masque[10];
pvoie->sr_mem = pvoie->seq = FALSE;
strcpy (w_masque, pvoie->appendf);
match = (int) w_masque[0];
if ((match) && (find (pvoie->appendf)))
ind = TRUE;
fptr = ouvre_nomenc ();
fseek (fptr, pvoie->enrcur, 0);
while (fread ((char *) &frec, sizeof (info), 1, fptr))
{
if (find (frec.indic.call))
{
if ((!ind && !match) || ((match) && (strmatch (frec.indic.call, w_masque))))
{
if ((masque == 0xffff) || ((int) frec.flags & masque))
{
if (pvoie->temp2 == 0)
texte (T_MBL + 11);
affiche_user (&frec, ind);
pvoie->temp2 = 1;
}
}
}
if (pvoie->memoc >= MAXMEM)
{
pvoie->sr_mem = TRUE;
retour = 1;
break;
}
if (trait_time > MAXTACHE)
{
pvoie->seq = TRUE;
retour = 1;
break;
}
}
pvoie->enrcur = ftell (fptr);
ferme (fptr, 37);
if ((retour == 0) && (pvoie->temp2 == 0))
texte (T_ERR + 19);
return (retour);
}
/* Commande J -> Liste des dernieres connexions */
int mbl_jheard (void)
{
int port;
if (isdigit (*indd))
{
while (*indd && (isdigit (*indd)))
{
port = (port * 10) + (*indd - '0');
++indd;
}
j_list (port, 0);
retour_mbl ();
return (0);
}
else
{
if (ISGRAPH (*(indd + 1)))
return (1); // erreur
*indd = toupper (*indd);
if (((*indd >= 'A') && (*indd <= 'J')) || (*indd == 'K')) // expanded from H to J to accomodate a little more ports
{
j_list (0, *indd);
retour_mbl ();
return (0);
}
}
return (1); // erreur
}
int page_connect (char port, FILE * fptr)
{
#define TBUF 20
long pos, nbc = MAXSTAT;
int nblig, nbrec, lg;
unsigned char valport;
statis buffstat[TBUF];
char valcall[8];
pvoie->lignes = -1;
nblig = nbl_page (voiecur);
if (nblig > MAXLIGNES)
nblig = MAXLIGNES;
nblig--;
if (nblig < 3)
nblig = 3;
nbrec = 0;
while (--nbc)
{
if (pvoie->noenr_menu == 0L)
return (FALSE);
if (nbrec == 0)
{
pos = pvoie->noenr_menu - (long) (sizeof (statis) * TBUF);
if (pos < 0L)
pos = 0L;
fseek (fptr, pos, 0);
nbrec = fread ((char *) buffstat, sizeof (statis), TBUF, fptr);
if (nbrec == 0)
return (FALSE);
}
--nbrec;
pvoie->noenr_menu -= (long) sizeof (statis);
lg = (strlen (pvoie->ch_temp));
if (strmatch (buffstat[nbrec].indcnx, pvoie->ch_temp))
{
/* test de la validite du port */
valport = buffstat[nbrec].port + 'A';
if ((!port) || (valport == port))
{
n_cpy (6, valcall, buffstat[nbrec].indcnx);
/* FlexNet Poll filtering - N1URO and WB2CMF */
if (strcmp(valcall, mycall)) {
sprintf (varx[0], "%c", valport);
sprintf (varx[1], "%02d", buffstat[nbrec].voie);
sprintf (varx[2], "%4ld", pvoie->noenr_menu / (long) sizeof (statis));
sprintf (varx[3], "%-6s", valcall);
sprintf (varx[4], "%2d", buffstat[nbrec].tpscnx / 60);
sprintf (varx[5], "%02d", buffstat[nbrec].tpscnx % 60);
ptmes->date = buffstat[nbrec].datcnx;
texte (T_STA + 23);
if (--nblig == 0)
break;
}
}
}
}
if (nbc == 0)
return (0);
return (1);
}
static int heardcmp (const void *a, const void *b)
{
long result;
result = ((Heard *) a)->last - ((Heard *) b)->last;
return ((result > 0L) ? 1 : ((result == 0L) ? 0 : -1));
}
void j_list (int portnum, char portlet)
{
FILE *fptr;
char buffer[259];
char date[80];
char indic[10];
int i, port;
Heard *pheard;
if (portnum)
{
port = portnum;
if ((port < 1) || (port >= NBPORT) || (p_port[port].pvalid == 0))
{
texte (T_ERR + 14);
return;
}
pheard = p_port[port].heard;
qsort (pheard, NBHEARD, sizeof (Heard), heardcmp);
for (i = 0; i < NBHEARD; i++)
{
if (pheard->last)
{
pheard->indic.call[6] = '\0';
if (pheard->indic.num > 15)
pheard->indic.num = 0;
sprintf (indic, "%s-%d",
pheard->indic.call, pheard->indic.num);
strcpy (date, datheure_mbl (pheard->first));
sprintf (buffer, "%-9s %s %s",
indic, date, datheure_mbl (pheard->last));
outln (buffer, strlen (buffer));
}
++pheard;
}
}
else
{
incindd ();
tester_masque ();
if (portlet == 'K')
port = '\0';
else
port = portlet;
if ((port) && ((port < 'A') || (port > 'J') || (p_port[port - 'A' + 1].pvalid == 0)))
{
texte (T_ERR + 14);
return;
}
fptr = ouvre_stats ();
fseek (fptr, 0L, 2);
pvoie->noenr_menu = ftell (fptr);
page_connect (port, fptr);
ferme (fptr, 38);
}
}
/*
void j_list (char type)
{
FILE *fptr;
char buffer[259];
char date[80];
char indic[10];
int i, port;
Heard *pheard;
if (isdigit (type))
{
port = type - '0';
if ((port < 1) || (port >= NBPORT) || (p_port[port].pvalid == 0))
{
texte (T_ERR + 14);
return;
}
pheard = p_port[port].heard;
qsort (pheard, NBHEARD, sizeof (Heard), heardcmp);
for (i = 0; i < NBHEARD; i++)
{
if (pheard->last)
{
pheard->indic.call[6] = '\0';
if (pheard->indic.num > 15)
pheard->indic.num = 0;
sprintf (indic, "%s-%d",
pheard->indic.call, pheard->indic.num);
strcpy (date, datheure_mbl (pheard->first));
sprintf (buffer, "%-9s %s %s",
indic, date, datheure_mbl (pheard->last));
outln (buffer, strlen (buffer));
}
++pheard;
}
}
else
{
incindd ();
tester_masque ();
if (type == 'K')
port = '\0';
else
port = type;
if ((port) && ((port < 'A') || (port > 'H') ||
(p_port[port - 'A' + 1].pvalid == 0)))
{
texte (T_ERR + 14);
return;
}
fptr = ouvre_stats ();
fseek (fptr, 0L, 2);
pvoie->noenr_menu = ftell (fptr);
page_connect (port, fptr);
ferme (fptr, 38);
}
}
*/
fbb-7.0.11/src/maint_fw.c 0000664 0001750 0001750 00000011325 13615565764 012037 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
#include
static int data_ok(recfwd *prec, int data_mode)
{
if ((data_mode == 0) && (prec->bin))
return 0;
if ((data_mode == 3) && (!prec->bin))
return 0;
if ((data_mode == 2) && (prec->bin) && (!PRIVATE (prec->type)))
return 0;
return 1;
}
int print_fwd (int nobbs, uchar max, uchar old, uchar typ, int data_mode)
{
int pos;
int noctet;
int ok = 0;
int pass = 2;
int aff = 0;
char cmpmsk;
recfwd *prec;
lfwd *ptr_fwd;
rd_list *ptemp = NULL;
time_t date = time(NULL) - 3600L * (long)old;
libere_tlist (voiecur);
noctet = (nobbs - 1) / 8;
cmpmsk = 1 << ((nobbs - 1) % 8);
ouvre_dir ();
while (pass)
{
pos = 0;
ptr_fwd = tete_fwd;
while (1)
{
aff = 0;
if (pos == NBFWD)
{
ptr_fwd = ptr_fwd->suite;
if (ptr_fwd == NULL)
break;
pos = 0;
}
prec = &ptr_fwd->fwd[pos];
if (prec->type)
{
if (data_ok(prec, data_mode))
{
if ((prec->fbbs[noctet] & cmpmsk) && (prec->date <= date) && (prec->kb <= max))
{
if ((prec->type == 'P') || (prec->type == 'A'))
{
if (pass == 2)
aff = 1;
}
else
{
if (pass == 1)
aff = 1;
}
if (aff)
{
if (ptemp)
{
ptemp->suite = (rd_list *) m_alloue (sizeof (rd_list));
ptemp = ptemp->suite;
}
else
{
pvoie->t_list = ptemp = (rd_list *) m_alloue (sizeof (rd_list));
}
ptemp->suite = NULL;
ptemp->nmess = prec->nomess;
ptemp->verb = 1;
ok = 1;
}
}
}
}
pos++;
}
if (typ)
break;
--pass;
}
ferme_dir ();
maj_niv (N_MBL, 16, 0);
mess_liste (1);
return (ok);
}
#if 0
int print_fwd (int nobbs, uchar max, uchar typ)
{
int pos;
int noctet;
int ok = 0;
int pass = 2;
int aff;
char cmpmsk;
rd_list *ptemp = NULL;
unsigned offset;
bloc_mess *bptr;
bullist bul;
libere_tlist (voiecur);
pos = 0;
noctet = (nobbs - 1) / 8;
cmpmsk = 1 << ((nobbs - 1) % 8);
ouvre_dir ();
while (pass)
{
offset = 0;
bptr = tete_dir;
while (bptr)
{
if (bptr->st_mess[offset].noenr)
{
read_dir (bptr->st_mess[offset].noenr, &bul);
if (bul.type)
{
int kb = (int) (bul.taille >> 10);
if ((bul.fbbs[noctet] & cmpmsk) && (kb <= max))
{
if ((bul.type == 'P') || (bul.type == 'A'))
{
if (pass == 2)
aff = 1;
}
else
{
if (pass == 1)
aff = 1;
}
if (aff)
{
if (ptemp)
{
ptemp->suite = (rd_list *) m_alloue (sizeof (rd_list));
ptemp = ptemp->suite;
}
else
{
pvoie->t_list = ptemp = (rd_list *) m_alloue (sizeof (rd_list));
}
ptemp->suite = NULL;
ptemp->nmess = bul.numero;
ptemp->verb = 1;
ok = 1;
}
}
}
}
if (++offset == T_BLOC_MESS)
{
bptr = bptr->suiv;
offset = 0;
}
}
if (typ)
break;
--pass;
}
ferme_dir ();
maj_niv (N_MBL, 16, 0);
mess_liste (1);
return (ok);
}
#endif
void maj_fwd (void)
{
int i, nb = 5;
char temp[NBMASK];
df ("maj_fwd", 0);
ouvre_dir ();
selvoie (CONSOLE);
vlang = 0;
pvoie->mode |= F_FOR;
while (nb)
{
if (read_dir (p_forward, ptmes) == 0)
{
p_forward = 0;
maj_options ();
aff_etat ('A');
aff_nbsta ();
break;
}
if ((*ptmes->bbsv) &&
(ptmes->status != 'H') &&
((ptmes->status == 'N') ||
(ptmes->status == 'Y') ||
(ptmes->status == '$')
))
{
aff_etat ('O');
nb = 0;
for (i = 0; i < NBMASK; i++)
{
temp[i] = ptmes->fbbs[i];
ptmes->fbbs[i] = '\0';
}
test_forward (2);
if (memcmp (ptmes->fbbs, temp, NBMASK) != 0)
{
clear_fwd (ptmes->numero);
ins_fwd (ptmes);
write_dir (p_forward, ptmes);
}
}
else
--nb;
++p_forward;
}
ferme_dir ();
ff ();
}
fbb-7.0.11/src/bidexms.c 0000664 0001750 0001750 00000021146 13613525371 011654 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
/*
* Gestion des BID memoire EMS/XMS
*
*/
#include
static unsigned nb_record;
static void tst_vbid (bullist *, int, int *);
static void tst_bid (bullist *, int, int *);
static int where_bid (char *bid);
/*
* Routines standard
*/
void w_bid (void)
{
int i;
long lnb, maxbid;
char *ptr;
FILE *fptr;
bidfwd fwbid;
maxbid = maxbbid;
if ((fptr = fopen (d_disque ("WFBID.SYS"), "r+b")) == NULL)
{
#ifdef ENGLISH
if (!svoie[CONSOLE]->sta.connect)
cprintf ("\r\nw_bid() Warning : Creating file %s \r\n\n", d_disque("WFBID.SYS"));
#else
if (!svoie[CONSOLE]->sta.connect)
cprintf ("\r\nw_bid() Warning : Cr‚ation du fichier %s\r\n\n", d_disque("WFBID.SYS"));
#endif
if ((fptr = fopen (d_disque ("WFBID.SYS"), "wb")) == NULL)
{
#ifdef ENGLISH
cprintf ("\r\nw_bid() Error : Impossible to create file %s \r\n\n", d_disque("WFBID.SYS"));
#else
cprintf ("\r\nw_bid() Erreur : Impossible de creer le fichier %s\r\n\n", d_disque("WFBID.SYS"));
#endif
fbb_error (ERR_CREATE, d_disque ("WFBID.SYS"), 0);
exit(1);
}
else {
ptr = (char *) &fwbid;
for (i = 0; i < sizeof (bidfwd); i++)
*ptr++ = '\0';
fwrite (&fwbid, sizeof (bidfwd), 1, fptr);
rewind (fptr);
}
}
fread (&fwbid, sizeof (fwbid), 1, fptr);
++fwbid.numero;
if ((fwbid.numero > maxbid) || (fwbid.numero < 1L))
fwbid.numero = 1L;
lnb = fwbid.numero;
rewind (fptr);
fwrite (&fwbid, sizeof (fwbid), 1, fptr);
fseek (fptr, fwbid.numero * sizeof (bidfwd), 0);
fwbid.mode = ptmes->type;
strncpy (fwbid.fbid, ptmes->bid, 12);
fwbid.fbid[12] = '\0';
fwbid.numero = ptmes->numero;
fwrite (&fwbid, sizeof (fwbid), 1, fptr);
ferme (fptr, 59);
--lnb;
if (bid_ptr)
{
/* Mise a jour du tableau */
ptr = bid_ptr + (int) (BIDCOMP * lnb);
memcpy (ptr, comp_bid (ptmes->bid), BIDCOMP);
}
else if (EMS_BID_OK ())
{
write_bid ((int) lnb, comp_bid (ptmes->bid));
}
}
int search_bid (char *bid)
{
int i;
char *ptr;
char t_bid[BIDCOMP];
if (bid_ptr)
{
memcpy (t_bid, comp_bid (bid), BIDCOMP);
ptr = bid_ptr;
for (i = 0; i < maxbbid; i++)
{
if (memcmp (ptr, t_bid, BIDCOMP) == 0)
{
return (i + 1);
}
ptr += BIDCOMP;
}
return (0);
}
else if (EMS_BID_OK ())
return (where_exms_bid (bid));
else
return (where_bid (bid));
}
void libere_bid (void)
{
if (bid_ptr)
{
m_libere (bid_ptr, (unsigned) (BIDCOMP * maxbbid));
bid_ptr = NULL;
}
}
void end_bids (void)
{
libere_bid ();
}
void cree_bid (void)
{
int i;
FILE *fptr;
bidfwd fwbuf;
bidfwd fwbid;
char *ptr;
#if defined(__WINDOWS__) || defined(__linux__)
char buffer[80];
#endif
#ifdef __FBBDOS__
fen *fen_ptr;
#endif
/* bid_exms = 0; */
nb_record = 0;
if ((fptr = fopen (d_disque ("WFBID.SYS"), "rb")) == NULL)
{
fprintf (stderr, "WFBID.SYS file is not present. Creating %s\n", d_disque("WFBID.SYS"));
printf ("WFBID.SYS is not present. Creating %s\n",d_disque("WFBID.SYS"));
if ((fptr = fopen (d_disque ("WFBID.SYS"), "wb")) == NULL)
{
#ifdef ENGLISH
cprintf ("\r\nError : Impossible to create file %s \r\n\n", d_disque("WFBID.SYS"));
#else
cprintf ("\r\nErreur : Impossible de cr<82>er le fichier %s\r\n\n", d_disque("WFBID.SYS"));
#endif
fbb_error (ERR_CREATE, d_disque ("WFBID.SYS"), 0);
exit(1);
}
else
{
ptr = (char *) &fwbid;
for (i = 0; i < sizeof (bidfwd); i++)
*ptr++ = '\0';
fwrite (&fwbid, sizeof (bidfwd), 1, fptr);
rewind (fptr);
}
}
deb_io ();
#ifdef __FBBDOS__
fen_ptr = open_win (10, 5, 50, 8, INIT, "BID");
#endif
if (EMS_BID_OK ())
{
init_exms_bid (fptr);
}
else
{
if ((bid_ptr == NULL) && (maxbbid <= 5000) && (tot_mem > 100000L))
{
bid_ptr = m_alloue ((unsigned) (BIDCOMP * maxbbid));
memset (bid_ptr, 0, (size_t) maxbbid * BIDCOMP);
ptr = bid_ptr;
for (i = 0; i < maxbbid; i++)
{
if ((i % 500) == 0)
{
#if defined(__WINDOWS__) || defined(__linux__)
InitText (ltoa ((long) i, buffer, 10));
#endif
#ifdef __FBBDOS__
cprintf ("\r%d BIDs", i);
#endif
}
fread (&fwbuf, sizeof (bidfwd), 1, fptr);
memcpy (ptr, comp_bid (fwbuf.fbid), BIDCOMP);
ptr += BIDCOMP;
}
#if defined(__WINDOWS__) || defined(__linux__)
InitText (ltoa ((long) i, buffer, 10));
#endif
#ifdef __FBBDOS__
cprintf ("\r%d BIDs", i);
#endif
}
}
ferme (fptr, 71);
#ifdef __FBBDOS__
sleep_ (1);
close_win (fen_ptr);
#endif
fin_io ();
}
static void tst_bid (bullist * fb_mess, int nb, int *t_res)
{
int i, j, res;
FILE *fptr;
bidfwd fwbid;
if ((fptr = fopen (d_disque ("WFBID.SYS"), "rb")) != NULL)
{
if (fread (&fwbid, sizeof (fwbid), 1, fptr) == 0)
return;
for (i = 0; i < maxbbid; i++)
{
if (fread (&fwbid, sizeof (fwbid), 1, fptr) == 0)
break;
res = 1;
for (j = 0; j < nb; j++) /* Test si tous sont trouves */
{
if ((t_res[j] == 0) && (*fb_mess[j].bid))
{
res = 0;
break;
}
}
if (res)
break;
for (j = 0; j < nb; j++)
{
if (t_res[j])
continue; /* Deja trouve ? */
if (*fb_mess[j].bid == '\0')
continue;
if (strcmp (fwbid.fbid, fb_mess[j].bid) == 0)
{
t_res[j] = 1;
}
}
}
ferme (fptr, 70);
}
}
static int where_bid (char *bid)
{
int i;
FILE *fptr;
bidfwd fwbid;
if ((fptr = fopen (d_disque ("WFBID.SYS"), "rb")) != NULL)
{
if (fread (&fwbid, sizeof (fwbid), 1, fptr) == 0)
return (0);
for (i = 0; i < maxbbid; i++)
{
if (fread (&fwbid, sizeof (fwbid), 1, fptr) == 0)
break;
if (strcmp (fwbid.fbid, bid) == 0)
{
return (i + 1);
}
}
ferme (fptr, 70);
}
return (0);
}
static void tst_vbid (bullist * fb_mess, int nb, int *t_res)
{
int i, j, res;
char *ptr;
char t_bid[MAX_FB][BIDCOMP];
for (i = 0; i < nb; i++)
if (*fb_mess[i].bid)
memcpy (t_bid[i], comp_bid (fb_mess[i].bid), BIDCOMP);
ptr = bid_ptr;
for (i = 0; i < maxbbid; i++)
{
res = 1;
for (j = 0; j < nb; j++)
{ /* Test si tous sont trouves */
if ((t_res[j] == 0) && (*fb_mess[j].bid))
{
res = 0;
break;
}
}
if (res)
break;
for (j = 0; j < nb; j++)
{
if (t_res[j])
continue; /* Deja trouve ? */
if (*fb_mess[j].bid == '\0')
continue;
if (strncmp (ptr, t_bid[j], BIDCOMP) == 0)
{
t_res[j] = 1;
}
}
ptr += BIDCOMP;
}
}
/*
Tests divers lors de la reception d'un message
Retour :
0 : Message accepte
1 : Message deja recu [ ou rejete (protocole 0) ]
2 : en cours de reception sur un autre canal
3 :
4 : Message rejete (protocole 1).
5 : Message retenu (protocole 1).
*/
int deja_recu (bullist * fb_mess, int nb, int *t_res)
{
int i, j, voie;
for (i = 0; i < nb; i++)
{
t_res[i] = rejet (&fb_mess[i]);
/*
if (t_res[i] == 0)
t_res[i] = retenu(&fb_mess[i]);
*/
}
for (i = 0; i < (nb - 1); i++)
{
for (j = i + 1; j < nb; j++)
{
if (t_res[j])
continue;
if (strcmp (fb_mess[i].bid, fb_mess[j].bid) == 0)
{
t_res[j] = 1;
break;
}
}
}
if (bid_ptr)
tst_vbid (fb_mess, nb, t_res);
else if (EMS_BID_OK ())
tst_exms_bid (fb_mess, nb, t_res);
else
tst_bid (fb_mess, nb, t_res);
for (i = 0; i < nb; i++)
{
if (t_res[i])
continue;
if (*fb_mess[i].bid == '\0')
continue;
/* Teste si en cours de reception */
for (voie = 0; voie < NBVOIES; voie++)
{
if ((voie == voiecur) || (!svoie[voie]->sta.connect))
continue;
if (strcmp (svoie[voie]->entmes.bid, fb_mess[i].bid) == 0)
{
t_res[i] = 2;
break;
}
for (j = 0; j < MAX_FB; j++)
{
if (svoie[voie]->fb_mess[j].type == '\0')
continue;
if (strcmp (svoie[voie]->fb_mess[j].bid, fb_mess[i].bid) == 0)
{
t_res[i] = 2;
break;
}
}
if (t_res[i])
break;
}
}
for (i = 0; i < nb; i++)
{
if (t_res[i] == 0)
t_res[i] = retenu (&fb_mess[i]);
}
return (t_res[0]);
}
fbb-7.0.11/src/mbl_kill.c 0000664 0001750 0001750 00000022340 13771323267 012010 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
#include
/*
* Module Nø1 emulation WA7MBL
*/
static int mbl_kill_liste (void);
static int mbl_kx (void);
static int teste_liste (bullist *);
static char *ltitre (int mode, bullist * pbul) /* Mode = 1 pour LS */
{
int lg = 80;
static char buf[100];
if (pvoie->typlist)
{
sprintf (buf, "%-12s ", pbul->bid);
if (mode)
strn_cpy (lg, buf + 13, pbul->titre);
else
n_cpy (lg, buf + 13, pbul->titre);
}
else
{
if (mode)
strn_cpy (lg, buf, pbul->titre);
else
n_cpy (lg, buf, pbul->titre);
}
return (buf);
}
static int strfind (bullist * pbul, char *cherche)
{
return (strmatch (ltitre (1, pbul), cherche));
}
static int teste_liste (bullist * lbul)
{
if (lbul->numero < pvoie->recliste.debut)
return (0);
if (lbul->numero > pvoie->recliste.fin)
return (0);
if (lbul->date < pvoie->recliste.avant)
return (0);
if (lbul->date > pvoie->recliste.apres)
return (0);
if (!droits (COSYSOP))
{
if (strcmp (lbul->desti, "KILL") == 0)
return (0);
if (lbul->type == 'A')
return (0);
if ((lbul->status == 'K') && (pvoie->recliste.status != 'K'))
return (0);
if ((lbul->status == 'A') && (pvoie->recliste.status != 'A'))
return (0);
}
if (*pvoie->recliste.find)
return (strfind (lbul, pvoie->recliste.find));
if ((pvoie->recliste.type) && (pvoie->recliste.type != lbul->type))
return (0);
if ((pvoie->recliste.status) && (pvoie->recliste.status != lbul->status))
return (0);
if ((*pvoie->recliste.exp) && (!strmatch (lbul->exped, pvoie->recliste.exp)))
return (0);
if ((*pvoie->recliste.dest) && (!strmatch (lbul->desti, pvoie->recliste.dest)))
return (0);
if (*pvoie->recliste.bbs)
{
if (*pvoie->recliste.bbs == '-')
{
if (*lbul->bbsv)
return (0);
}
else
{
if (!strmatch (bbs_via (lbul->bbsv), pvoie->recliste.bbs))
return (0);
}
}
return (1);
}
/* Commande 'K' -> Kill messages ou 'H' -> hold message */
int supp_nomess (long no, int archive)
{
int i;
int kill_new = 0;
bullist lbul;
char s[80];
char type = '\0';
if (archive >= 0x80)
{
archive -= 0x80;
kill_new = 1;
}
switch (archive)
{
case 0:
type = 'K';
break;
case 1:
type = 'A';
break;
case 2:
type = 'H';
break;
}
if (!ch_record (&lbul, no, 0))
return (2);
if (archive == 2)
{
if ((lbul.status != '$') && (lbul.status != 'N') && (lbul.status != 'Y'))
return (2);
}
if (!droit_ok (&lbul, (archive == 1) ? 3 : ((kill_new) ? 4 : 2)))
return (3);
ch_record (&lbul, no, (kill_new) ? (type | 0x80) : type);
sprintf (s, "%c %ld", type, lbul.numero);
fbb_log (voiecur, 'M', s);
clear_fwd (lbul.numero);
lbul.status = type;
for (i = 0; i < NBMASK; i++)
{
lbul.fbbs[i] = '\0';
}
maj_rec (lbul.numero, &lbul);
if (archive == 2)
++nb_hold;
return (1);
}
static void kill_mine (int archive)
{
/* Suppression des messages personnels */
int trouve = 0;
unsigned num_ind = pvoie->no_indic;
unsigned offset = 0;
bullist bul;
bloc_mess *bptr = tete_dir;
mess_noeud *mptr;
ouvre_dir ();
while (bptr)
{
mptr = &(bptr->st_mess[offset]);
if (mptr->noenr == 0)
break;
if (mptr->no_indic == num_ind)
{
read_dir (mptr->noenr, &bul);
*ptmes = bul;
if (bul.status != 'H')
{
trouve = 1;
if (bul.status != 'N')
{
switch (supp_nomess (bul.numero, archive))
{
case 1:
texte (T_MBL + 7);
break;
case 2: /* Deja tue ! */
break;
case 3:
texte (T_ERR + 12);
break;
}
}
else
texte (T_ERR + 12);
}
}
if (++offset == T_BLOC_MESS)
{
bptr = bptr->suiv;
offset = 0;
}
}
ferme_dir ();
if (!trouve)
texte (T_MBL + 3);
}
static int mbl_kill_liste (void)
{
int retour = 1;
bullist ligne;
unsigned offset = pvoie->recliste.offset;
bloc_mess *bptr = pvoie->recliste.ptemp;
int archive = pvoie->recliste.l;
mess_noeud *mptr;
pvoie->sr_mem = pvoie->seq = FALSE;
ouvre_dir ();
while (bptr)
{
mptr = &(bptr->st_mess[offset]);
if (mptr->noenr == 0)
break;
read_dir (mptr->noenr, &ligne);
if (ligne.numero < pvoie->recliste.debut)
break;
if (teste_liste (&ligne))
{
if (pvoie->recliste.last-- == 0L)
break;
if (droit_ok (&ligne, 2))
{
switch (supp_nomess (ligne.numero, archive))
{
case 1:
if (archive == 2)
outln ("Msg #$M held.", 13);
else
texte (T_MBL + 7);
break;
case 2: /* Deja tue ! */
ptmes->numero = ligne.numero;
break;
case 3:
ptmes->numero = ligne.numero;
if (archive == 2)
texte (T_ERR + 13);
else
texte (T_ERR + 12);
break;
}
pvoie->temp1 = 0;
}
}
if (++offset == T_BLOC_MESS)
{
bptr = bptr->suiv;
offset = 0;
}
if (pvoie->memoc >= MAXMEM)
{
pvoie->sr_mem = TRUE;
retour = 0;
break;
}
if (trait_time > MAXTACHE)
{
pvoie->seq = TRUE;
retour = 0;
break;
}
}
ferme_dir ();
pvoie->recliste.offset = offset;
pvoie->recliste.ptemp = bptr;
if ((retour) && (pvoie->temp1))
texte (T_MBL + 3);
return (retour);
}
int mbl_kill (void)
{
int error = 0;
switch (pvoie->niv3)
{
case 0:
error = mbl_kx ();
break;
case 1:
if (mbl_kill_liste ())
retour_mbl ();
break;
default:
fbb_error (ERR_NIVEAU, "MESS-KILL", pvoie->niv3);
}
return (error);
}
static int mbl_kx (void)
{
long no;
char c;
int archive = 0, fin = 1, suite = 1;
int error = 0;
sup_ln (indd);
c = toupper (*indd);
init_recliste (voiecur);
pvoie->aut_nc = 1;
if (droits (SUPMES))
{
if (c == 'K')
{
++indd;
c = toupper (*indd);
archive = 1;
}
switch (c)
{
case '>':
++indd;
suite = 0;
if (teste_espace ())
{
strn_cpy (6, pvoie->recliste.dest, indd);
fin = 0;
}
else
{
texte (T_ERR + 2);
}
break;
case '<':
++indd;
suite = 0;
if (teste_espace ())
{
strn_cpy (6, pvoie->recliste.exp, indd);
fin = 0;
}
else
{
texte (T_ERR + 2);
}
break;
case 'F':
++indd;
suite = 0;
pvoie->recliste.status = 'F';
fin = 0;
break;
case '@':
++indd;
suite = 0;
if (teste_espace ())
{
strn_cpy (6, pvoie->recliste.bbs, indd);
fin = 0;
}
else
{
texte (T_ERR + 2);
}
break;
default:
break;
}
if ((!fin) && (!suite))
{
pvoie->recliste.ptemp = tete_dir;
pvoie->recliste.offset = 0;
pvoie->recliste.l = archive;
pvoie->temp1 = 1;
if (mbl_kill_liste ())
fin = 1;
else
ch_niv3 (1);
}
}
if (suite)
{
if (c == 'M')
{
kill_mine (archive);
}
else
{
if (teste_espace ())
{
while ((no = lit_chiffre (1)) != 0L)
{
/* Autorise la suppression des messages non lus */
switch (supp_nomess (no, archive + 0x80))
{
case 1:
texte (T_MBL + 7);
break;
case 2:
texte (T_ERR + 10);
break;
case 3:
texte (T_ERR + 12);
break;
}
}
}
else
{
/* texte(T_ERR + 3) ; */
error = 1;
fin = 0;
}
}
}
if (fin)
retour_mbl ();
return (error);
}
/*
* Archive = 0 -> K
* 1 -> A
* 2 -> H
*/
int hold_kill (int archive)
{
long no;
char c;
int fin = 1, suite = 1;
int error = 0;
c = toupper (*indd);
switch (c)
{
case '>':
++indd;
suite = 0;
if (teste_espace ())
{
strn_cpy (6, pvoie->recliste.dest, indd);
fin = 0;
}
else
{
texte (T_ERR + 2);
}
break;
case '<':
++indd;
suite = 0;
if (teste_espace ())
{
strn_cpy (6, pvoie->recliste.exp, indd);
fin = 0;
}
else
{
texte (T_ERR + 2);
}
break;
case 'F':
if (archive != 2)
{
++indd;
suite = 0;
pvoie->recliste.status = 'F';
fin = 0;
}
break;
case '@':
++indd;
suite = 0;
if (teste_espace ())
{
strn_cpy (6, pvoie->recliste.bbs, indd);
fin = 0;
}
else
{
texte (T_ERR + 2);
}
break;
default:
break;
}
if ((!fin) && (!suite))
{
pvoie->recliste.ptemp = tete_dir;
pvoie->recliste.offset = 0;
pvoie->recliste.l = archive;
pvoie->temp1 = 1;
if (mbl_kill_liste ())
fin = 1;
else
ch_niv3 (1);
}
if (suite)
{
if (teste_espace ())
{
while ((no = lit_chiffre (1)) != 0L)
{
switch (supp_nomess (no, archive))
{
case 1:
outln ("Msg #$M held.", 13);
break;
case 2:
break;
case 3:
texte (T_ERR + 10);
break;
}
}
}
else
{
error = 1;
fin = 0;
}
}
if (fin)
retour_mbl ();
return (error);
}
fbb-7.0.11/src/mbl_menu.c 0000664 0001750 0001750 00000030645 13613525371 012023 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
/*
* MBL_MENU.C
*
*/
#include
/*
* Pas de forward si read-only
* si pas déclaré BBS sur un port GUEST
*/
int forward_auth (int voie)
{
/* Toujours OK sur l'import/export */
if (voie == INEXPORT)
return (1);
if (POP (no_port (voie)))
return (1);
if (svoie[voie]->read_only)
return 0;
if (std_header & 128)
{
/* N'accepte que si BBS declarees */
if ((BBS (svoie[voie]->finf.flags)) || (PMS (svoie[voie]->finf.flags)))
return (1);
else
return (0);
}
if ((P_GUEST (voie)) && (!BBS (svoie[voie]->finf.flags)))
return 0;
return 1;
}
static void menu_mbl (void)
{
int c, error = 0;
int cmd = 1;
char com[80];
char *pt_err = indd;
char *ptr;
limite_commande ();
while (*indd && (!ISGRAPH (*indd)))
indd++;
strn_cpy (70, com, indd);
ptr = strchr (com, ' ');
if (ptr)
*ptr = '\0';
c = *indd++;
if ((!SYS (pvoie->finf.flags)) && (voiecur != CONSOLE) &&
(!LOC (pvoie->finf.flags)) && (P_GUEST (voiecur)))
{
switch (toupper (c))
{
case 'A':
interruption (voiecur);
break;
case 'B':
if (bye ())
{
maj_niv (N_MENU, 0, 0);
sortie ();
}
else
{
cmd_err (--indd);
}
break;
case 'F':
if (FOR (pvoie->mode))
{
if (*indd == '>')
{
maj_niv (N_FORW, 1, 0);
rcv_rev_fwd ();
}
else
{
maj_niv (N_MENU, 0, 0);
sortie ();
}
}
else
error = 1;
break;
case 'K':
if (!read_only ())
{
if (toupper (*indd) == 'M')
{
maj_niv (N_MBL, 4, 0);
mbl_kill ();
}
else
error = 1;
}
else
retour_mbl ();
break;
case 'L':
if ((toupper (*indd) == 'M') || (toupper (*indd) == 'N'))
{
maj_niv (N_MBL, 1, 0);
mbl_list ();
}
else
error = 1;
break;
case 'N':
maj_niv (N_MBL, 7, 0);
error = mbl_name ();
break;
case 'O':
maj_niv (N_MBL, 11, 0);
error = mbl_options ();
retour_mbl ();
break;
/* Added by N1URO for cross-node command set compatability */
case 'Q':
if (quit ())
{
maj_niv (N_MENU, 0, 0);
sortie ();
}
case 'R':
if ((toupper (*indd) == 'M') || (toupper (*indd) == 'N'))
{
maj_niv (N_MBL, 2, 0);
mbl_read (0);
}
else
error = 1;
break;
case 'S':
maj_niv (N_MBL, 3, 0);
mbl_send ();
break;
case 'T':
maj_niv (N_MBL, 9, 0);
mbl_tell ();
break;
case 'X':
if (EXP (pvoie->finf.flags))
{
pvoie->finf.flags &= (~F_EXP);
texte (T_MBL + 18);
}
else
{
pvoie->finf.flags |= F_EXP;
texte (T_MBL + 17);
}
/* pvoie->finf.flags = pvoie->mode ; */
if (!pvoie->read_only)
ch_info ();
retour_mbl ();
break;
case '[':
if (forward_auth (voiecur))
{
while (ISGRAPH (*indd))
++indd;
if (*(indd - 1) == ']')
{
analyse_idnt (pt_err);
if (pvoie->prot_fwd & FWD_FBB)
{
pvoie->temp1 = 0;
pvoie->ind_mess = 0;
pvoie->temp2 = FALSE;
init_rec_fwd (voiecur);
maj_niv (N_FORW, 5, 2);
return;
}
else
pvoie->mode |= F_BBS;
prompt (pvoie->finf.flags, pvoie->niv1);
}
else
cmd_err (pt_err);
}
else
cmd_err (--indd);
break;
case '*':
/* if ((*indd == '*') && (*(indd + 1) == '*'))
{
indd += 3;
if (test_linked ())
{
traite_voie (voiecur);
}
}
else */
{
cmd_err (--indd);
}
cmd = 0;
break;
case 'H':
if ((*indd) && (strncmpi (indd, "ELP", 3) == 0))
{
int nb = 0;
while ((*indd) && (!isspace (*indd)))
{
++indd;
++nb;
}
if (nb != 3)
{
error = 1;
break;
}
}
else if (ISGRAPH (*indd))
{
error = 1;
break;
}
case '?':
while (isspace (*indd))
++indd;
help (indd);
break;
case ';':
cmd = 0;
break;
case '\0':
cmd = 0;
prompt (pvoie->finf.flags, N_MBL);
break;
default:
cmd = 0;
--indd;
if (!defaut ())
error = 1;
break;
}
if (error)
{
cmd_err (pt_err);
}
}
else
{
if (!appel_pg (com))
{
switch (toupper (c))
{
case 'A':
if (!ISGRAPH (*indd))
interruption (voiecur);
else
error = 1;
break;
case 'B':
if (bye ())
{
maj_niv (N_MENU, 0, 0);
sortie ();
}
else
error = 1;
/* {
cmd_err(--indd) ;
} */
break;
case 'C':
maj_niv (N_CONF, 0, 0);
error = conference ();
break;
case 'D':
maj_niv (N_MBL, 8, 0);
error = mbl_dump ();
break;
case 'E':
if (droits (COSYSOP))
{
maj_niv (N_MBL, 11, 0);
error = mbl_edit ();
}
else
error = 1;
/* {
cmd_err(--indd) ;
} */
break;
case 'F':
switch (toupper (*indd))
{
case '>':
if (FOR (pvoie->mode))
{
if (pvoie->prot_fwd & FWD_XPRO)
{
maj_niv (N_XFWD, 1, 5);
xfwd ();
}
else
{
maj_niv (N_FORW, 1, 0);
rcv_rev_fwd ();
}
}
else
error = 1;
break;
case '<':
if (FOR (pvoie->mode))
{
send_binary_mess ();
}
else
error = 1;
break;
case '\r':
if (miniserv & 1)
{
pvoie->mbl = FALSE;
texte (T_MBL + 19);
/* pvoie->finf.flags |= F_EXP ; */
maj_niv (0, 1, 0);
prompt (pvoie->finf.flags, pvoie->niv1);
}
else
error = 1;
break;
default:
if (droits (COSYSOP))
error = maint_fwd ();
else
error = 1;
break;
}
break;
case 'G':
if (!ISGRAPH (*indd))
{
if (((gate) && nbgate () && (!pvoie->read_only)) || (voiecur == CONSOLE))
{
pvoie->temp3 = pvoie->niv1;
maj_niv (N_TELL, 0, 0);
pvoie->mbl = 0;
duplex_tnc ();
}
else
{
texte (T_GAT + 8);
retour_mbl ();
}
}
else
error = 1;
break;
case 'H':
sup_ln (indd);
if (*indd)
{
if (strncmpi (indd, "ELP", 3) == 0)
{
int nb = 0;
while ((*indd) && (!isspace (*indd)))
{
++indd;
++nb;
}
if (nb != 3)
{
error = 1;
break;
}
}
else
{
error = mbl_hold ();
break;
}
}
case '?':
while (isspace (*indd))
++indd;
help (indd);
break;
case 'I':
maj_niv (N_MBL, 5, 0);
error = menu_wp_search ();
break;
case 'J':
maj_niv (N_MBL, 10, 0);
error = mbl_jheard ();
break;
case 'K':
if (!read_only ())
{
maj_niv (N_MBL, 4, 0);
error = mbl_kill ();
}
else
retour_mbl ();
break;
case 'L':
maj_niv (N_MBL, 1, 0);
pvoie->typlist = 0;
error = mbl_list ();
break;
case 'M':
c = toupper (*indd);
if ((!ISGRAPH (c)) || (c == 'V') || (c == 'H') || (c == 'A'))
{
error = mess_fic ();
}
else
{
if (droits (COSYSOP))
{
maj_niv (N_MBL, 1, 0);
pvoie->typlist = 1;
error = mbl_list ();
}
else
{
error = 1;
/* cmd_err(--indd) ; */
}
}
break;
case 'N':
maj_niv (N_MBL, 7, 0);
error = mbl_name ();
break;
case 'O':
maj_niv (N_MBL, 11, 0);
error = mbl_options ();
retour_mbl ();
break;
case 'P':
if (!p_cmd ())
error = 1;
break;
/* Added by N1URO for cross-node command set compatability */
case 'Q':
if (quit())
{
maj_niv (N_MENU, 0, 0);
sortie();
}
else
error = 1;
break;
case 'R':
maj_niv (N_MBL, 2, 0);
error = mbl_read (0);
break;
case 'S':
maj_niv (N_MBL, 3, 0);
error = mbl_send ();
break;
case 'T':
if (!ISGRAPH (*indd))
{
maj_niv (N_MBL, 9, 0);
mbl_tell ();
}
else if (toupper (*indd) == 'H')
{
maj_niv (N_THEMES, 0, 0);
error = themes ();
}
else
error = 1;
break;
case 'U':
if (!ISGRAPH (*indd))
{
if (!is_room ())
{
outln ("*** Disk full !", 15);
retour_mbl ();
break;
}
--indd;
pvoie->temp1 = pvoie->niv1;
strcpy (pvoie->dos_path, "\\");
maj_niv (N_DOS, 3, 0);
receive_file ();
}
else
error = 1;
break;
case 'V':
maj_niv (N_MBL, 6, 0);
error = mbl_read (1);
break;
case 'W':
if (!ISGRAPH (*indd))
{
--indd;
pvoie->temp1 = pvoie->niv1;
strcpy (pvoie->dos_path, "\\");
maj_niv (N_DOS, 1, 0);
dir ();
}
else
error = 1;
break;
case 'X':
if (!ISGRAPH (*indd))
{
if (EXP (pvoie->finf.flags))
{
pvoie->finf.flags &= (~F_EXP);
texte (T_MBL + 18);
}
else
{
pvoie->finf.flags |= F_EXP;
texte (T_MBL + 17);
}
/* pvoie->finf.flags = pvoie->mode ; */
if (!pvoie->read_only)
ch_info ();
retour_mbl ();
}
else
error = 1;
break;
case 'Y':
if (ISGRAPH (*indd))
{
if ((toupper (*indd) == 'D') && (!user_ok ()))
{
texte (T_ERR + 18);
retour_mbl ();
}
else
{
maj_niv (N_YAPP, 0, 0);
pvoie->temp1 = pvoie->niv1;
error = (menu_yapp () == 0);
}
}
else
help ("Y");
break;
case 'Z':
if (!ISGRAPH (*indd))
{
--indd;
pvoie->temp1 = pvoie->niv1;
strcpy (pvoie->dos_path, "\\");
maj_niv (N_DOS, 7, 0);
del_file ();
}
else
error = 1;
break;
case '$':
if (droits (COSYSOP))
{
incindd ();
mbl_disbul ();
retour_mbl ();
}
else
error = 1;
break;
case '[':
if (forward_auth (voiecur))
{
while (ISGRAPH (*indd))
++indd;
if (*(indd - 1) == ']')
{
analyse_idnt (pt_err);
if (pvoie->prot_fwd & FWD_FBB)
{
pvoie->temp1 = 0;
pvoie->ind_mess = 0;
pvoie->temp2 = FALSE;
init_rec_fwd (voiecur);
maj_niv (N_FORW, 5, 2);
return;
}
else
pvoie->mode |= F_BBS;
prompt (pvoie->finf.flags, pvoie->niv1);
}
else
cmd_err (pt_err);
}
else
cmd_err (--indd);
break;
case '*':
if ((*indd == '*') && (*(indd + 1) == '*'))
{
indd += 3;
if (test_linked ())
{
traite_voie (voiecur); /* Il y a des actions */
}
}
else
{
cmd_err (--indd);
}
cmd = 0;
break;
case ';':
cmd = 0;
break;
case '\0':
cmd = 0;
prompt (pvoie->finf.flags, N_MBL);
break;
default:
cmd = 0;
--indd;
if (defaut () == 0)
{
++indd;
if (appel_pg (com) == 0)
error = 1;
}
break;
}
if (error)
{
cmd_err (com);
}
}
}
if (cmd)
{
pvoie->aut_linked = 0;
}
}
void mbl_emul (void)
{
df ("mbl_emul", 0);
switch (pvoie->niv2)
{
case N_MENU:
menu_mbl ();
break;
case N_FORW:
mbl_send ();
break;
case 1:
mbl_list ();
break;
case 2:
mbl_read (pvoie->recliste.l);
break;
case 3:
break;
case 4:
mbl_kill ();
break;
case 5:
wp_search ();
break;
case 6:
mbl_read (pvoie->recliste.l);
break;
case 7:
mbl_name ();
break;
case 8:
mbl_dump ();
break;
case 9:
mbl_tell ();
break;
case 11:
mbl_edit ();
break;
case 13:
duplex_tnc ();
break;
case 14:
mbl_passwd ();
break;
case 16:
mess_liste (1);
break;
case 17:
exec_pg ();
break;
case 18:
review ();
break;
case 19:
#ifdef __WINDOWS__
end_win_edit ();
#endif
#ifdef __FBBDOS__
end_mini_edit ();
#endif
break;
#ifdef __linux__
case 20:
exec_cmd (NULL);
break;
#endif
case 98:
export_message (io_fich);
break;
case 99:
import_message (io_fich);
break;
}
ff ();
}
fbb-7.0.11/src/variable.c 0000664 0001750 0001750 00000026716 13613525371 012016 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
/*
* VARIABLE.C
*
*/
#include
static char locbuf[600];
char *strdate (long temps)
{
static char cdate[19];
char jour[4];
struct tm *sdate;
df ("strdate", 2);
sdate = localtime (&temps);
if (vlang == -1)
*jour = '\0';
else
{
strncpy (jour, (langue[vlang]->plang[JOUR - 1]) + (sdate->tm_wday * 3), 3);
jour[3] = '\0';
}
sprintf (cdate, "%s %02d/%02d/%02d %02d:%02d",
jour, sdate->tm_mday,
sdate->tm_mon + 1, sdate->tm_year % 100,
sdate->tm_hour, sdate->tm_min);
ff ();
return (cdate);
}
char *strdt (long temps)
{
struct tm *sdate;
static char cdate[15];
df ("strdt", 2);
sdate = localtime (&temps);
sprintf (cdate, "%02d/%02d/%02d %02d:%02d",
sdate->tm_mday,
sdate->tm_mon + 1, sdate->tm_year % 100,
sdate->tm_hour, sdate->tm_min);
ff ();
return (cdate);
}
static char *date_heure_fbb (long temps)
{
struct tm *sdate;
static char cdate[15];
df ("data_heure_fbb", 2);
sdate = localtime (&temps);
sprintf (cdate, "%02d%02d/%02d%02d",
sdate->tm_mon + 1, sdate->tm_mday,
sdate->tm_hour, sdate->tm_min);
ff ();
return (cdate);
}
char *date_mbl (long temps)
{
struct tm *sdate;
static char cdate[7];
df ("data_mbl", 2);
sdate = localtime (&temps);
sprintf (cdate, "%02d%02d%02d", sdate->tm_year % 100, sdate->tm_mon + 1, sdate->tm_mday);
ff ();
return (cdate);
}
char *heure_mbl (long temps)
{
struct tm *sdate;
static char cdate[5];
df ("heure_mbl", 2);
sdate = localtime (&temps);
sprintf (cdate, "%02d%02d", sdate->tm_hour, sdate->tm_min);
ff ();
return (cdate);
}
static char *date_mbl_new (long temps)
{
char mois[4];
struct tm *sdate;
static char cdate[7];
df ("date_mbl_new", 2);
sdate = localtime (&temps);
if (vlang == -1)
*mois = '\0';
else
{
strncpy (mois, (langue[vlang]->plang[MOIS - 1]) + (sdate->tm_mon * 3), 3);
mois[3] = '\0';
}
sprintf (cdate, "%02d-%s", sdate->tm_mday, mois);
ff ();
return (cdate);
}
static char *annee_mbl (long temps)
{
struct tm *sdate;
static char cdate[7];
df ("annee_mbl", 2);
sdate = localtime (&temps);
sprintf (cdate, "%02d", sdate->tm_year % 100);
ff ();
return (cdate);
}
char *datheure_mbl (long temps)
{
static char cdate[13];
df ("datheure_mbl", 2);
sprintf (cdate, "%s %s", date_mbl_new (temps), strheure (temps));
ff ();
return (cdate);
}
char *strheure (long temps)
{
struct tm *sdate;
static char cdate[6];
df ("str_heure", 2);
sdate = localtime (&temps);
sprintf (cdate, "%02d:%02d", sdate->tm_hour, sdate->tm_min);
ff ();
return (cdate);
}
int jour (long temps)
{
struct tm *sdate;
df ("jour", 2);
sdate = localtime (&temps);
ff ();
return (sdate->tm_wday);
}
int nojour (long temps)
{
struct tm *sdate;
df ("nojour", 2);
sdate = localtime (&temps);
ff ();
return (sdate->tm_mday);
}
int heure (long temps)
{
struct tm *sdate;
df ("heure", 2);
sdate = localtime (&temps);
ff ();
return (sdate->tm_hour);
}
int gmt_heure (long temps)
{
struct tm *sdate;
df ("heure", 2);
sdate = gmtime (&temps);
ff ();
return (sdate->tm_hour);
}
int minute (long temps)
{
struct tm *sdate;
df ("minute", 2);
sdate = localtime (&temps);
ff ();
return (sdate->tm_min);
}
static int check_fwd (char *bbs, int *nbbul, int *nbpriv, int *nbkilo)
{
char maxfwd[NBBBS + 1];
char typfwd[NBBBS + 1];
char typdat[NBBBS + 1];
atfwd *mess;
int nobbs;
static unsigned task_ident = 0xffff;
static atfwd smess;
*nbbul = *nbpriv = *nbkilo = 0;
nobbs = n_bbs (bbs);
if (nobbs == 0)
return (FALSE);
if (task_ident != tid)
{
task_ident = tid;
fwd_value (maxfwd, typfwd, typdat);
if ((mess = attend_fwd (nobbs, maxfwd[nobbs], 0, typfwd[nobbs], typdat[nobbs])) != NULL)
{
smess = *mess;
}
else
{
memset (&smess, 0, sizeof (atfwd));
}
}
*nbpriv = smess.nbpriv;
*nbbul = smess.nbbul;
*nbkilo = smess.nbkb;
return (TRUE);
}
char *variable (char var)
{
int nb;
long t_cnx;
char *ptr = locbuf;
df ("variable", 1);
*ptr = '\0';
switch (var)
{
case '$':
*ptr++ = '$';
*ptr = '\0';
break;
/* Variables red‚finies */
case '0':
n_cpy (80, ptr, varx[0]);
break;
case '1':
n_cpy (80, ptr, varx[1]);
break;
case '2':
n_cpy (80, ptr, varx[2]);
break;
case '3':
n_cpy (80, ptr, varx[3]);
break;
case '4':
n_cpy (80, ptr, varx[4]);
break;
case '5':
n_cpy (80, ptr, varx[5]);
break;
case '6':
n_cpy (80, ptr, varx[6]);
break;
case '7':
n_cpy (80, ptr, varx[7]);
break;
case '8':
n_cpy (80, ptr, varx[8]);
break;
case '9':
n_cpy (80, ptr, varx[9]);
break;
/* Variable pr‚d‚finies */
case 'A':
sprintf (ptr, "%-6s", bbs_via (ptmes->bbsv));
break;
case 'a':
strcpy (ptr, annee_mbl (time (NULL)));
break;
case 'B':
*ptr++ = '\a';
*ptr = '\0';
break;
case 'b':
strcpy (ptr, pvoie->finf.zip);
break;
case 'C':
ltoa (nomess + 1, ptr, 10);
break;
case 'c':
strcpy (ptr, my_city);
break;
case 'D':
strcpy (ptr, date_mbl (time (NULL)));
break;
case 'd':
strcpy (ptr, date_mbl_new (time (NULL)));
break;
case 'E':
strcpy (ptr, version ());
break;
case 'e':
strcpy (ptr, pvoie->finf.ville);
break;
case 'F':
itoa (p_port[no_port (voiecur)].min_fwd, ptr, 10);
break;
case 'f':
strcpy (ptr, pvoie->appendf);
break;
case 'G':
sprintf (ptr, "%-6s", ptmes->desti);
break;
case 'g':
itoa (nbgate (), ptr, 10);
break;
case 'H':
strcpy (ptr, strheure (time (NULL)));
break;
case 'h':
strcpy (ptr, pvoie->finf.home);
break;
case 'I':
if (*(pvoie->finf.prenom))
strcpy (ptr, pvoie->finf.prenom);
else
strcpy (ptr, "???");
break;
case 'i':
strcpy (ptr, date_heure_fbb (ptmes->date));
break;
case 'J':
strcpy (ptr, date_mbl (ptmes->date));
break;
case 'j':
strcpy (ptr, date_mbl_new (ptmes->date));
break;
case 'K':
strcpy (ptr, strheure (ptmes->date));
break;
case 'k':
strcpy (ptr, k_var ());
break;
case 'L':
ltoa (nomess, ptr, 10);
break;
case 'l':
if (*pvoie->finf.filtre)
strcpy (ptr, pvoie->finf.filtre);
else
{
*ptr++ = '*';
*ptr = '\0';
}
break;
case 'M':
sprintf (ptr, "%-6ld", ptmes->numero);
break;
case 'm':
strcpy (ptr, p_port[no_port (voiecur)].freq);
break;
case 'N':
ltoa (nbmess, ptr, 10);
break;
case 'n':
sprintf (ptr, "%5ld", ptmes->taille);
break;
case 'O':
strcpy (ptr, mycall);
break;
case 'o':
itoa (myssid, ptr, 10);
break;
case 'P':
sprintf (ptr, "%-6s", ptmes->exped);
break;
case 'p':
if (PAG (pvoie->finf.flags))
ltoa (pvoie->finf.nbl, ptr, 10);
else
{
ptr[0] = ptr[1] = '-';
ptr[2] = '\0';
}
break;
case 'Q':
list_new (ptr);
break;
case 'q':
ltoa (1000L * (long) pvoie->finf.on_base, ptr, 10);
break;
case 'R':
strcpy (ptr, ptmes->bid);
break;
case 'r':
*ptr++ = (*ptmes->bbsf) ? ' ' : 'L';
*ptr = '\0';
break;
case 'S':
strcpy (ptr, ptmes->titre);
break;
case 's':
*ptr++ = ptmes->status;
*ptr = '\0';
break;
case 'T':
strcpy (ptr, strheure (time (NULL)));
break;
case 't':
*ptr++ = ptmes->type;
*ptr = '\0';
break;
case 'U':
strcpy (ptr, pvoie->sta.indicatif.call);
break;
case 'u':
*ptr++ = (pvoie->vdisk == 8) ? 'P' : pvoie->vdisk + 'A';
*ptr = '\0';
break;
case 'V':
strcpy (ptr, my_name);
break;
case 'v':
strcpy (ptr, ptmes->bbsv);
break;
case 'W':
*ptr++ = '\r';
*ptr = '\0';
break;
case 'w':
*ptr++ = '\033';
*ptr = '\0';
break;
case 'X':
strcpy (ptr, date_mbl (pvoie->finf.hcon));
break;
case 'x':
strcpy (ptr, date_mbl_new (pvoie->finf.hcon));
break;
case 'Y':
strcpy (ptr, strheure (pvoie->finf.hcon));
break;
case 'y':
strcpy (ptr, annee_mbl (ptmes->date));
break;
case 'Z':
ltoa (pvoie->finf.lastmes, ptr, 10);
break;
case 'z':
strcpy (ptr, my_zip);
break;
case '*':
nb = actif (1);
itoa (nb, ptr, 10);
break;
case '=':
itoa (virt_canal (voiecur), ptr, 10);
break;
case '!':
itoa (no_port (voiecur), ptr, 10);
break;
case '^':
itoa (nbport (), ptr, 10);
break;
case '?':
strcpy (ptr, qra_locator);
break;
case '%':
who (ptr);
break;
case ':':
t_cnx = time (NULL) - pvoie->debut;
if (t_cnx < 60)
sprintf (ptr, "%2lds", t_cnx);
else
sprintf (ptr, "%ldmn %02lds", t_cnx / 60, t_cnx % 60);
break;
case '.':
if (pvoie->tmach < 60)
sprintf (ptr, "%2lds", pvoie->tmach);
else
sprintf (ptr, "%ldmn %02lds", pvoie->tmach / 60, pvoie->tmach % 60);
break;
default:
sprintf (ptr, "$%c", var);
break;
}
ff ();
return (locbuf);
}
char *alt_variable (char var)
{
int nbbul, nbpriv, nbkilo;
char *ptr = locbuf;
Wps *wps;
df ("alt_variable", 1);
*ptr = '\0';
switch (var)
{
case '%':
*ptr++ = '%';
*ptr = '\0';
break;
/* Variable pr‚d‚finies */
case 'A':
sprintf (ptr, "%s", bbs_via (ptmes->bbsv));
break;
case 'C':
sprintf (ptr, "%-3u", ptmes->nblu);
break;
case 'd':
itoa (pvoie->finf.download, ptr, 10);
break;
case 'E':
strcpy (ptr, os ());
break;
case 'e':
strcpy (ptr, date ());
break;
case 'G':
sprintf (ptr, "%s", ptmes->desti);
break;
case 'I':
/* Get the name from WP */
wps = wp_find(ptmes->exped, 0);
if ((wps) && (*wps->name) && (*wps->name != '?'))
strcpy (ptr, wps->name);
else
strcpy (ptr, "???");
break;
case 'i':
strcpy (ptr, date_heure_fbb (ptmes->datesd));
break;
case 'J':
strcpy (ptr, date_mbl (ptmes->datesd));
break;
case 'j':
strcpy (ptr, date_mbl_new (ptmes->datesd));
break;
case 'K':
strcpy (ptr, strheure (ptmes->datesd));
break;
case 'k':
check_fwd (pvoie->sta.indicatif.call, &nbbul, &nbpriv, &nbkilo);
itoa (nbkilo, ptr, 10);
break;
case 'l':
check_fwd (pvoie->sta.indicatif.call, &nbbul, &nbpriv, &nbkilo);
itoa (nbpriv + nbbul, ptr, 10);
break;
case 'M':
sprintf (ptr, "%ld", ptmes->numero);
break;
case 'm':
itoa (P_MODM (voiecur) ? max_mod : max_yapp, ptr, 10);
break;
case 'N':
sprintf (ptr, "%ld", ptmes->numero % 0x10000L);
break;
case 'n':
sprintf (ptr, "%ld", ptmes->taille);
break;
case 'O':
strcpy (ptr, admin);
break;
case 'P':
sprintf (ptr, "%s", ptmes->exped);
break;
case 'R':
strcpy (ptr, mypath);
break;
case 'r':
*ptr++ = (ptmes->bin) ? 'D' : ' ';
*ptr = '\0';
break;
case 'T':
strcpy (ptr, cur_theme (voiecur));
break;
case 't':
itoa (nbull_theme (voiecur), ptr, 10);
break;
case 'X':
itoa (pvoie->ncur->nbmess, ptr, 10);
break;
case 'x':
itoa (pvoie->ncur->nbnew, ptr, 10);
break;
case 'y':
strcpy (ptr, annee_mbl (ptmes->datesd));
break;
default:
sprintf (ptr, "%%%c", var);
break;
}
ff ();
return (locbuf);
}
fbb-7.0.11/src/initport.c 0000664 0001750 0001750 00000061526 13613525371 012077 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
#include
static int lang_len (char *);
static void errport (int, char *);
static void err_fic (char *, int, char *);
static void init_forward (Forward * pfwd)
{
int i;
int j;
pfwd->reverse = 0;
pfwd->fwdpos = 0;
pfwd->lastpos = 0;
pfwd->fwdlig = 0;
pfwd->cptif = 0;
pfwd->forward = 0;
pfwd->no_con = 0;
pfwd->no_bbs = 0;
pfwd->fin_fwd = 0;
for (i = 0; i < 8; i++)
{
*pfwd->con_lig[i] = '\0';
}
for (i = 0; i < 4; i++)
{
for (j = 0; j < 3; j++)
{
*pfwd->mesnode[i][j] = '\0';
}
}
*pfwd->txt_con = '\0';
*pfwd->fwdbbs = '\0';
pfwd->suite = NULL;
}
void end_ports (void)
{
int i;
Forward *pfwd;
if (p_port == NULL)
return;
for (i = 0; i < NBPORT; i++)
{
while (p_port[i].listfwd)
{
pfwd = p_port[i].listfwd;
p_port[i].listfwd = pfwd->suite;
m_libere (pfwd, sizeof (Forward));
}
}
m_libere (p_port, sizeof (defport) * NBPORT);
p_port = NULL;
}
void initport (void)
{
FILE *fptr;
Forward *pprec, *pfwd;
char *ptr;
char ligne[256], sfreq[81], mode[81];
char portname[81];
int voie;
#ifdef __linux__
int linux_canal = 1;
#endif
int drsi_canal = 1;
int bpq_canal = 1;
int agw_canal = 1;
int hst_canal = 1;
int lig;
int j;
unsigned int p1, p2, p3, p4, p5, p6, p7, p8, p9;
long lp4;
int mx;
int nbvalid = 0, i = 0;
int nb, nbl, tnc = 0, nbport;
int local_mode, nbtnc, fvoie; /* flag de lecture d'affectation des voies */
unsigned al;
char *portfile;
lig = 0;
al = sizeof (defcom) * NBPORT;
p_com = (defcom *) m_alloue (al);
memset (p_com, 0, sizeof (defcom) * NBPORT);
#ifdef __FBBDOS__
portfile = "port_d.sys";
#endif
#ifdef __WINDOWS__
portfile = "port_w.sys";
#endif
#ifdef __linux__
portfile = "port_l.sys";
#endif
if ((fptr = fopen (c_disque (portfile), "r")) == NULL)
{
if ((fptr = fopen (c_disque ("port.sys"), "r")) == NULL)
{
#ifdef ENGLISH
errport (lig, "File PORT.SYS not found");
#else
errport (lig, "Fichier PORT.SYS inexistant");
#endif
return;
}
}
#ifdef __linux__
#ifdef ENGLISH
cprintf ("Ports set-up \n");
#else
cprintf ("Initialisation des ports\n");
#endif
#else
#ifdef ENGLISH
cprintf ("Ports set-up \r\n");
#else
cprintf ("Initialisation des ports\r\n");
#endif
#endif
al = sizeof (defport) * NBPORT;
p_port = (defport *) m_alloue (al);
for (i = 0; i < NBPORT; i++)
{
p_port[i].mem = 32000;
p_port[i].pvalid = p_port[i].nb_voies = 0;
p_port[i].transmit = 0;
p_port[i].cur_can = 0;
p_port[i].portind = 0;
p_port[i].synchro = 0;
p_port[i].frame = 0;
for (j = 0; j < NBHEARD; j++)
p_port[i].heard[j].last = 0L;
}
p_port[0].pvalid = 1; /* Port console valide */
p_port[0].typort = TYP_DED;
p_port[0].moport = 0;
p_port[0].frame = 4;
/******************* A PARAMETRER *******************/
p_port[0].min_fwd = 0;
p_port[0].per_fwd = 15;
strcpy (p_port[0].freq, "CONSOLE");
p_port[0].listfwd = (Forward *) m_alloue (sizeof (Forward));
init_forward (p_port[0].listfwd);
svoie[0]->sta.mem = 500;
svoie[0]->affport.port = 0xfe;
svoie[0]->affport.canal = -2;
/* voie pour import/export */
init_voie (NBVOIES);
svoie[NBVOIES]->sta.mem = 500;
svoie[NBVOIES]->affport.port = 0;
svoie[NBVOIES]->affport.canal = 1;
++NBVOIES;
fvoie = 1;
nbl = 0;
while (fgets (ligne, 250, fptr))
{
++lig;
ptr = ligne;
while (*ptr && (*ptr == ' '))
++ptr;
if (*ptr == '#')
continue;
if (!isdigit (*ptr))
{
#ifdef ENGLISH
errport (lig, "Syntax error ");
#else
errport (lig, "Erreur de syntaxe");
#endif
return;
}
switch (fvoie)
{
case 1:
nb = sscanf (ptr, "%d %d", &nbport, &nbtnc);
if (nb != 2)
{
#ifdef ENGLISH
errport (lig, "Wrong number of parameters ");
#else
errport (lig, "Nombre de paramŠtres incorrect");
#endif
return;
}
if ((nbport <= 0) || (nbport > (NBPORT - 1)))
{
#ifdef ENGLISH
errport (lig, "Port number error ");
#else
errport (lig, "Nombre de ports erron‚");
#endif
return;
}
if (nbtnc < nbport)
{
#ifdef ENGLISH
errport (lig, "TNC number error ");
#else
errport (lig, "Nombre de TNCs erron‚");
#endif
return;
}
fvoie = 2;
break;
case 2:
nb = sscanf (ptr, "%d %d %s %ld", &p1, &p3, portname, &lp4);
if (nb != 4)
{
#ifdef ENGLISH
errport (lig, "Wrong number of parameters ");
#else
errport (lig, "Nombre de paramŠtres incorrect");
#endif
return;
}
if ((p1 <= 0) || (p1 > NBCOM))
{
#ifdef ENGLISH
errport (lig, "COM Nb error ");
#else
errport (lig, "Nø COM erron‚");
#endif
return;
}
p2 = 0;
sscanf (portname, "%x", &p2);
n_cpy (19, p_com[p1].name, portname);
p_com[p1].delai = 0;
p_com[p1].cbase = p2;
p_com[p1].pactor_st = 247;
#ifdef __linux__
if (p3 != P_LINUX)
{
#ifdef ENGLISH
errport (lig, "Wrong interface number ");
#else
errport (lig, "Num‚ro d'interface erron‚");
#endif
return;
}
#endif
#ifdef __FBBDOS__
if (p3 > P_TFPC)
{
#ifdef ENGLISH
errport (lig, "Wrong interface number ");
#else
errport (lig, "Num‚ro d'interface erron‚");
#endif
return;
}
#endif
#ifdef __WINDOWS__
if (p3 > P_TFWIN)
{
#ifdef ENGLISH
errport (lig, "Wrong interface number ");
#else
errport (lig, "Num‚ro d'interface erron‚");
#endif
return;
}
#endif
p_com[p1].combios = p3;
p_com[p1].port = (int) lp4;
#ifdef __WINDOWS__
if (p3 == P_WINDOWS)
{
p_com[p1].baud = lp4;
}
else
{
#endif
#if defined(__linux__) || defined(__FBBDOS__)
if (p3)
{
#endif
switch (lp4)
{
case 300L:
p_com[p1].baud = 0x43;
p_com[p1].options = 0;
break;
case 600L:
p_com[p1].baud = 0x63;
p_com[p1].options = 0;
break;
case 1200L:
p_com[p1].baud = 0x83;
p_com[p1].options = 0;
break;
case 2400L:
p_com[p1].baud = 0xA3;
p_com[p1].options = 0;
break;
case 4800L:
p_com[p1].baud = 0xC3;
p_com[p1].options = 0;
break;
case 0L:
case 9600L:
p_com[p1].baud = 0xE3;
p_com[p1].options = 0;
break;
case 14400L:
p_com[p1].baud = 0x23;
p_com[p1].options = 0x20;
break;
case 19200L:
p_com[p1].baud = 0x43;
p_com[p1].options = 0x20;
break;
case 28800L:
p_com[p1].baud = 0x63;
p_com[p1].options = 0x20;
break;
case 38400L:
p_com[p1].baud = 0x83;
p_com[p1].options = 0x20;
break;
case 57600L:
p_com[p1].baud = 0xA3;
p_com[p1].options = 0x20;
break;
case 115200L:
p_com[p1].baud = 0xC3;
p_com[p1].options = 0x20;
break;
case 330400L:
p_com[p1].baud = 0xE3;
p_com[p1].options = 0x20;
break;
default:
#ifdef __linux__
break;
#else
#ifdef ENGLISH
errport (lig, "Wrong baud rate ");
#else
errport (lig, "Baud rate incorrect");
#endif
return;
#endif
}
}
#ifdef __FBBDOS__
else
{
p_com[p1].options = 0x0;
switch (lp4)
{
case 300L:
p_com[p1].baud = 384;
break;
case 600L:
p_com[p1].baud = 192;
break;
case 1200L:
p_com[p1].baud = 96;
break;
case 2400L:
p_com[p1].baud = 48;
break;
case 4800L:
p_com[p1].baud = 24;
break;
case 9600L:
p_com[p1].baud = 12;
break;
case 14400L:
p_com[p1].baud = 9;
break;
case 19200L:
p_com[p1].baud = 6;
break;
case 28800L:
p_com[p1].baud = 4;
break;
case 38400L:
p_com[p1].baud = 3;
break;
case 57600L:
p_com[p1].baud = 2;
break;
case 115200L:
p_com[p1].baud = 1;
break;
case 330400L:
p_com[p1].baud = 0;
break;
default:
#ifdef ENGLISH
errport (lig, "Wrong baud rate ");
#else
errport (lig, "Baud rate incorrect");
#endif
return;
}
}
#endif /* __FBBDOS__ */
if (++nbl == nbport)
{
fvoie = 3;
nbl = 0;
tnc = 0;
voie = 1;
}
break;
case 3:
p5 = 0;
nb = sscanf (ptr, "%d %d %d %s %d %d %d %d %d/%d %s %s",
&p1, &p2, &p4, portname, &p6, &p7, &p9, &mx, &p3, &p8, mode, sfreq);
if (nb != 12)
{
#ifdef ENGLISH
errport (lig, "Wrong number of parameters ");
#else
errport (lig, "Nombre de paramŠtres incorrect");
#endif
return;
}
if (p1 > NBPORT)
{
#ifdef ENGLISH
errport (lig, "Wrong port number ");
#else
errport (lig, "Num‚ro port erron‚");
#endif
return;
}
if (p2 > MAXVOIES)
{
#ifdef ENGLISH
errport (lig, "Number of channels");
#else
errport (lig, "Nombre de voies ");
#endif
return;
}
if (p2 > 0)
{
sscanf (portname, "%d", &p5);
if (p5 > 99)
p5 = 0;
n_cpy (19, p_port[p1].name, portname);
if ((p4 < 1) || (p4 > NBCOM))
{
#ifdef ENGLISH
errport (lig, "COM Nb error ");
#else
errport (lig, "Nø COM erron‚");
#endif
return;
}
#ifndef __linux__
if (p5 > 7)
{
#ifdef ENGLISH
errport (lig, "Channel must be from 0 to 7");
#else
errport (lig, "Le canal doit etre de 0 … 7");
#endif
return;
}
#endif
if ((p6 != 0) && ((p6 < 30) || (p6 > 250)))
{
#ifdef ENGLISH
errport (lig, "Paclen must be from 30 to 250 ");
#else
errport (lig, "Le paquet doit etre de 30 … 250");
#endif
return;
}
if ((p7 < 1) || (p7 > 7))
{
#ifdef ENGLISH
errport (lig, "Maxframe must be from 1 to 7 ");
#else
errport (lig, "Le nombre de trames doit etre de 1 … 7");
#endif
return;
}
if (p9 > p2)
{
#ifdef ENGLISH
errport (lig, "Too many forward channels");
#else
errport (lig, "Trop de voies forward ");
#endif
return;
}
if (mx <= 0)
{
#ifdef ENGLISH
errport (lig, "Forwarding block size");
#else
errport (lig, "Taille bloc forward ");
#endif
return;
}
if (strlen (sfreq) > 9)
{
#ifdef ENGLISH
errport (lig, "9 characters maximum for the frequency");
#else
errport (lig, "9 caracteres maximum pour la frequence");
#endif
return;
}
if (p3 > 59)
{
#ifdef ENGLISH
errport (lig, "Forward minute");
#else
errport (lig, "Minute forward");
#endif
return;
}
if ((p8 < 1) || (p8 > 60))
{
#ifdef ENGLISH
errport (lig, "Forward period ");
#else
errport (lig, "P‚riode forward");
#endif
return;
}
}
/* Gestion du multiplexeur sur le COM (DED) */
p_com[p4].multi[p5] = p1;
if (p1 == 0)
{
if (p3 > 59)
{
#ifdef ENGLISH
errport (lig, "Forward minute");
#else
errport (lig, "Minute forward");
#endif
return;
}
if ((p8 < 1) || (p8 > 60))
{
#ifdef ENGLISH
errport (lig, "Forward period ");
#else
errport (lig, "P‚riode forward");
#endif
return;
}
p_port[p1].min_fwd = p3;
p_port[p1].per_fwd = p8;
break;
}
if (p_port[p1].pvalid)
{
errport (lig, "TNC number already declared");
}
p_port[p1].ccom = p4;
p_port[p1].ccanal = p5;
p_port[p1].maxbloc = mx;
ptr = mode;
p_port[p1].typort = TYP_DED;
p_port[p1].moport = 0;
while (*ptr)
{
switch (toupper (*ptr))
{
case 'G':
p_port[p1].moport |= 1;
break;
case 'B':
p_port[p1].moport |= 2;
break;
case 'Y':
p_port[p1].moport |= 4;
break;
case 'M':
p_port[p1].moport |= 8;
p_port[p1].typort = TYP_MOD; /* MODEM */
break;
case 'W':
p_port[p1].moport |= 0x10;
break;
case 'L':
p_port[p1].moport |= 0x20;
break;
case 'R':
p_port[p1].moport |= 0x40;
break;
#ifdef __linux__
case 'S':
p_port[p1].typort = TYP_POP; /* POP SOCKET */
p_port[p1].ccanal = 0;
p5 = 0;
break;
case 'X':
p_port[p1].typort = TYP_SCK; /* AX25 SOCKET */
p_port[p1].ccanal = 0;
p5 = 0;
break;
#endif
case 'H':
p_port[p1].typort = TYP_HST; /* PTC-HOST */
break;
case 'D':
p_port[p1].typort = TYP_DED; /* DED */
if ((p_com[p4].combios == P_COMBIOS) && ((p5 < 1) || (p5 > 4)))
{
#ifdef ENGLISH
errport (lig, "Mux channel must be from 1 to 4");
#else
errport (lig, "Le canal MUX doit etre de 1 a 4");
#endif
return;
}
break;
case 'P':
p_port[p1].typort = TYP_PK; /* PK232 */
if (p2 > 9)
p2 = 9;
break;
case 'K':
p_port[p1].typort = TYP_KAM; /* KAM */
break;
case 'Q':
p_port[p1].typort = TYP_BPQ; /* BPQ4 */
p_port[p1].ccanal = p5 + 1;
break;
#if defined(__WINDOWS__) || defined(__linux__)
case 'T':
p_port[p1].typort = TYP_TCP; /* TCP-IP */
break;
case 'E':
p_port[p1].typort = TYP_ETH; /* ETHER-LINK */
break;
#endif
#if defined(__WINDOWS__)
case 'A':
p_port[p1].typort = TYP_AGW; /* TCP-AGW */
break;
#endif
#if defined(__WINDOWS__) || defined(__FBBDOS__)
case 'F':
p_port[p1].typort = TYP_FLX; /* FLEXNET */
break;
#endif
case 'U':
break;
default:
#ifdef ENGLISH
errport (lig, "Wrong port mode ");
#else
errport (lig, "Mode du port erron‚");
#endif
return;
}
++ptr;
}
p_port[p1].pk_t = p6;
if ((p_port[p1].typort == TYP_HST) && (p_port[p1].ccanal == 0))
{
/* Pactor port */
p_port[p1].moport |= 0x80;
}
if (p6)
p_port[p1].beacon_paclen = p6;
else
p_port[p1].beacon_paclen = 128;
switch (p_com[p4].combios)
{
case 3:
p_port[p1].typort = TYP_MOD;
p_port[p1].moport |= 8;
p_port[p1].pk_t = 128;
break;
case 4:
p_port[p1].typort = TYP_DED;
break;
default:
break;
}
p_port[p1].pvalid = p_port[p1].nb_voies = p2;
p_port[p1].frame = p7;
p_port[p1].listfwd = pprec = NULL;
p_port[p1].min_fwd = p3;
p_port[p1].per_fwd = p8;
p_port[p1].pr_voie = NBVOIES;
while (p9--)
{
pfwd = (Forward *) m_alloue (sizeof (Forward));
if (p_port[p1].listfwd)
{
pprec->suite = pfwd;
pprec = pfwd;
}
else
{
p_port[p1].listfwd = pprec = pfwd;
}
init_forward (pprec);
}
strn_cpy (9, p_port[p1].freq, sfreq);
if (p2)
{
int tot;
#if defined(__WINDOWS__) || defined(__linux__)
{
char buf[80];
sprintf (buf, "%d %d ch", p1, p2);
InitText (buf);
}
#endif
#ifdef __FBBDOS__
#ifdef ENGLISH
cprintf ("Port %d ok : %d channel(s) \r\n", p1, p2);
#else
cprintf ("Port %d valide : %d voie(s)\r\n", p1, p2);
#endif
#endif
nbvalid += p2;
tot = 0;
for (i = 1; i <= p2; i++)
{
init_voie (NBVOIES);
svoie[NBVOIES]->affport.port = p1;
#ifdef __linux__
if (S_LINUX (p1))
{
tot = linux_canal++;
svoie[NBVOIES]->affport.canal = tot;
}
else
#endif
if (DRSI (p1))
{
tot = drsi_canal++;
svoie[NBVOIES]->affport.canal = tot;
}
else if (BPQ (p1))
{
tot = bpq_canal++;
svoie[NBVOIES]->affport.canal = tot;
}
else if (AGW (p1))
{
tot = agw_canal++;
svoie[NBVOIES]->affport.canal = tot;
}
else if (HST (p1))
{
if (p_port[p1].ccanal == 0)
{
tot = 1;
svoie[NBVOIES]->affport.canal = PACTOR_CH;
}
else
{
/* Include the pactor channel */
tot = hst_canal++;
svoie[NBVOIES]->affport.canal = tot;
if (tot == PACTOR_CH)
{
#ifdef ENGLISH
errport (lig, "Too many channels ! ");
#else
errport (lig, "Nombre de voies trop important");
#endif
}
}
}
else
{
tot = i;
svoie[NBVOIES]->affport.canal = tot;
}
if (++NBVOIES == MAXVOIES)
{
#ifdef ENGLISH
errport (lig, "Too many channels ! ");
#else
errport (lig, "Nombre de voies trop important");
#endif
return;
}
}
p_port[p1].tt_can = tot;
}
if (++tnc == nbtnc)
{
fvoie = 4;
nbl = 0;
}
break;
case 4:
nb = sscanf (ptr, "%d %d %s %s", &p1, &p2, sfreq, mode);
if (nb != 4)
{
#ifdef ENGLISH
errport (lig, "Wrong parameter number ");
#else
errport (lig, "Nombre de paramŠtres incorrect");
#endif
return;
}
if (p2 > p_port[p1].nb_voies)
{
#ifdef ENGLISH
errport (lig, "Not enough channels on this port");
#else
errport (lig, "Pas assez de voies sur ce port ");
#endif
return;
}
ptr = mode;
local_mode = 0;
while (*ptr)
{
switch (toupper (*ptr))
{
case 'G':
local_mode |= 1;
break;
case 'B':
local_mode |= 2;
break;
case 'Y':
local_mode |= 4;
break;
case 'U':
break;
default:
#ifdef ENGLISH
errport (lig, "Wrong port mode ");
#else
errport (lig, "Mode du port erron‚");
#endif
return;
}
++ptr;
}
i = NBVOIES;
while (p2)
{
if (--i == 0)
break;
if (no_port (i) == p1)
{
svoie[i]->sta.callsign.num =
extind (sfreq, svoie[i]->sta.callsign.call);
svoie[i]->localmode = local_mode;
#ifdef ENGLISH
cprintf ("Channel %d on %s \r\n", i, sfreq);
#else
cprintf ("Voie %d affectee a %s\r\n", i, sfreq);
#endif
--p2;
}
}
break;
case 5:
break;
}
}
for (voie = 0; voie < NBVOIES; voie++)
{
svoie[voie]->paclen = p_port[no_port (voie)].pk_t;
}
#ifdef __linux__
#ifdef ENGLISH
cprintf ("%d channels ok \n", nbvalid);
#else
cprintf ("%d voies valides\n", nbvalid);
#endif
#else
#ifdef ENGLISH
cprintf ("%d channels ok \r\n", nbvalid);
#else
cprintf ("%d voies valides\r\n", nbvalid);
#endif
#endif
MWARNING = NBVOIES;
init_voie (MWARNING);
ferme (fptr, 6);
attend_caractere (1);
}
static void errport (int lig, char *texte)
{
#ifdef __FBBDOS__
#ifdef ENGLISH
cprintf ("Error file PORT.SYS line %d : \r\n< %s >\r\n\a", lig, texte);
#else
cprintf ("Erreur fichier PORT.SYS ligne %d : \r\n< %s >\r\n\a", lig, texte);
#endif
attend_caractere (10);
#endif
#if defined(__WINDOWS__) || defined(__linux__)
char msg[80];
#ifdef ENGLISH
sprintf (msg, "Error file PORT.SYS line %d : \n< %s >", lig, texte);
#else
sprintf (msg, "Erreur fichier PORT.SYS ligne %d : \n< %s >", lig, texte);
#endif
WinMessage (5, msg);
#endif
fbb_error (ERR_SYNTAX, c_disque ("PORT.SYS"), lig);
}
static void err_fic (char *nomfic, int ligne, char *texte)
{
#ifdef __FBBDOS__
cprintf ("\r\n%s (%d) : %s\r\n\a", nomfic, ligne, texte);
attend_caractere (10);
#endif
#if defined(__WINDOWS__) || defined(__linux__)
char msg[80];
sprintf (msg, "%s (%d) :\n%s", nomfic, ligne, texte);
WinMessage (0, msg);
#endif
fbb_error (ERR_SYNTAX, nomfic, ligne);
}
static unsigned int tail_lang = 0;
void end_textes (void)
{
int cpt;
if (langue == NULL)
return;
m_libere (nomlang, LG_LANG * maxlang);
for (cpt = 0; cpt < NBLANG; cpt++)
{
m_libere (langue[cpt]->plang[0], tail_lang);
m_libere (langue[cpt], sizeof (tlang));
}
m_libere (langue, NBLANG * sizeof (tlang *));
langue = NULL;
vlang = -1;
}
void initexte (void)
{
int cpt, nb, niv, nbc, ligne;
unsigned int taille = 0;
FILE *fptr;
char s[81], nomfic[81];
#ifdef __FBBDOS__
fen *fen_ptr;
#endif
ligne = niv = 0;
strcpy (nomfic, "LANGUE.SYS");
if ((fptr = fopen (c_disque (nomfic), "rt")) == NULL)
{
#ifdef ENGLISH
err_fic (nomfic, ligne, "File LANGUE.SYS not found ");
#else
err_fic (nomfic, ligne, "Erreur ouverture LANGUE.SYS");
#endif
return;
}
#ifdef __linux__
#ifdef ENGLISH
cprintf ("Texts set-up \n");
#else
cprintf ("Initialisation des textes\n");
#endif
#else
#ifdef ENGLISH
cprintf ("Texts set-up \r\n");
#else
cprintf ("Initialisation des textes\r\n");
#endif
#endif
nbc = cpt = 0;
#ifdef ENGLISH
strcpy (s, " Texts set-up ");
#else
strcpy (s, "Initialisation des textes");
#endif
#ifdef __FBBDOS__
fen_ptr = open_win (10, 6, 60, 16, INIT, s);
#endif
while (fgets (s, 80, fptr))
{
++ligne;
if (*s == '#')
continue;
switch (niv)
{
case 0:
if (isdigit (*s))
{
nb = sscanf (s, "%d %d %d", &nbc, &NBLANG, &deflang);
if (nb != 3)
{
deflang = 0;
NBLANG = 3;
}
if (deflang > nbc)
deflang = 0;
else
deflang--;
/*
if (NBLANG < 2)
NBLANG = 2 ;
*/
if (NBLANG > nbc)
NBLANG = nbc;
if (nbc < 1)
#ifdef ENGLISH
err_fic (nomfic, ligne, "Error languages number ");
#else
err_fic (nomfic, ligne, "Erreur nombre de langues");
#endif
}
else
#ifdef ENGLISH
err_fic (nomfic, ligne, "Error : No languages number");
#else
err_fic (nomfic, ligne, "Manque nombre de langues ");
#endif
++niv;
nomlang = (char *) m_alloue (LG_LANG * nbc);
#ifdef __linux__
#ifdef ENGLISH
cprintf ("%d language buffers allocated\n", NBLANG);
#else
cprintf ("%d buffers langue allou‚s \n", NBLANG);
#endif
#else
#ifdef ENGLISH
cprintf ("%d language buffers allocated\r\n", NBLANG);
#else
cprintf ("%d buffers langue allou‚s \r\n", NBLANG);
#endif
#endif
break;
case 1:
if (!ISPRINT (*nomfic))
break;
strn_cpy (LG_LANG - 1, nomlang + cpt * LG_LANG, sup_ln (s));
#ifdef __WINDOWS__
InitText (nomlang + cpt * LG_LANG);
#endif
#ifdef __FBBDOS__
cprintf ("\r\n%8s ", nomlang + cpt * LG_LANG);
#endif
#ifdef __linux__
printf ("Init lang %9s\n", nomlang + (cpt * LG_LANG));
#endif
nb = lang_len (nomlang + (cpt * LG_LANG));
if (taille < nb)
taille = nb;
if (++cpt == nbc)
++niv;
break;
}
if (niv == 2)
break;
}
fclose (fptr);
maxlang = cpt;
tail_lang = taille;
/* Alloue les NBLANG buffers de pointeurs et de textes */
langue = (tlang * *)m_alloue (NBLANG * sizeof (tlang *));
for (cpt = 0; cpt < NBLANG; cpt++)
{
langue[cpt] = (tlang *) m_alloue (sizeof (tlang));
langue[cpt]->plang[0] = (char *) m_alloue (taille);
langue[cpt]->numlang = -1;
}
swap_langue (0, deflang);
#ifdef __FBBDOS__
close_win (fen_ptr);
#endif
}
static int lang_len (char *nom_lang)
{
char nomfic[81];
char texte[81];
char chaine[300];
int nb, taille;
FILE *fpl;
sprintf (nomfic, "LANG\\%s.TXT", nom_lang);
if ((fpl = fopen (c_disque (nomfic), "rb")) == NULL)
{
#ifdef ENGLISH
sprintf (chaine, "File %s not found", nomfic);
#else
sprintf (chaine, "Erreur fichier %s", nomfic);
#endif
err_fic (nomfic, 0, chaine);
}
taille = (size_t) 0;
nb = 0;
while (fgets (chaine, 257, fpl))
{
if ((*chaine == '#') || (*chaine == '\0') || (*chaine == '\032'))
continue;
taille += (unsigned int) strlen (chaine);
if (++nb > NBTEXT)
break;
#ifdef __FBBDOS__
if ((nb % 10) == 0)
putch ('.');
#endif
}
if (nb != NBTEXT)
{
#ifdef ENGLISH
sprintf (texte, "Wrong line number : need %d - found %d ", NBTEXT, nb);
#else
sprintf (texte, "Nombre de lignes incorrect : attendu %d - trouve %d", NBTEXT, nb);
#endif
err_fic (nomfic, nb, texte);
}
fclose (fpl);
return (taille + 256);
}
void swap_langue (int num_buf, int num_lang)
{
char nomfic[81];
char chaine[300];
char *txt_ptr;
int nb;
FILE *fpl;
#ifdef __FBBDOS__
fen *fen_ptr;
#endif
if (langue[num_buf]->numlang == num_lang)
return;
txt_ptr = langue[num_buf]->plang[0];
sprintf (nomfic, "LANG\\%s.TXT", nomlang + num_lang * LG_LANG);
if ((fpl = fopen (c_disque (nomfic), "rb")) == NULL)
{
#ifdef ENGLISH
sprintf (chaine, "File %s not found", nomfic);
#else
sprintf (chaine, "Erreur fichier %s", nomfic);
#endif
err_fic (nomfic, 0, chaine);
}
deb_io ();
#ifdef __FBBDOS__
#ifdef ENGLISH
fen_ptr = open_win (55, 4, 75, 6, INIT, " Text ");
#else
fen_ptr = open_win (55, 4, 75, 6, INIT, "Textes");
#endif
#endif
nb = 0;
while (fgets (chaine, 257, fpl))
{
sup_ln (chaine);
if ((*chaine == '#') || (*chaine == '\0'))
continue;
#ifdef __FBBDOS__
if ((nb % 50) == 0)
putch ('.');
#endif
strcpy (txt_ptr, chaine);
langue[num_buf]->plang[nb] = txt_ptr;
txt_ptr += strlen (chaine) + 1;
++nb;
if (nb > NBTEXT)
break;
}
fclose (fpl);
langue[num_buf]->numlang = num_lang;
#ifdef __FBBDOS__
close_win (fen_ptr);
#endif
fin_io ();
}
void read_heard (void)
{
int i;
FILE *fptr;
if ((fptr = fopen (d_disque ("HEARD.BIN"), "rb")) != NULL)
{
for (i = 0; i < NBPORT; i++)
{
fread (p_port[i].heard, sizeof (Heard), NBHEARD, fptr);
}
fclose (fptr);
}
}
void write_heard (void)
{
int i;
FILE *fptr;
if (p_port == NULL)
return;
if ((fptr = fopen (d_disque ("HEARD.BIN"), "wb")) != NULL)
{
for (i = 0; i < NBPORT; i++)
{
fwrite (p_port[i].heard, sizeof (Heard), NBHEARD, fptr);
}
fclose (fptr);
}
}
fbb-7.0.11/src/mbl_expo.c 0000664 0001750 0001750 00000015370 13613525371 012030 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
#include
#define CTRL_Z '\032'
static int out_disk (FILE *, char *);
static int mess_export (FILE * fptr, int voie, long temps, long no_message)
{
char lastchar = '\0';
char type;
char s[255];
char ret[2];
char header[160];
char via[80];
FILE *f_mptr;
char buffer[300];
ret[0] = 13;
ret[1] = 0;
if (*svoie[voie]->entmes.bbsv)
sprintf (via, "@ %s ", svoie[voie]->entmes.bbsv);
else
*via = '\0';
type = svoie[voie]->entmes.type;
if (type == 'A')
type = 'P';
sprintf (s, "S%c %s %s< %s",
type, svoie[voie]->entmes.desti, via, svoie[voie]->entmes.exped);
if (!out_disk (fptr, s))
return (0);
if (*(svoie[voie]->entmes.bid))
{
sprintf (s, " $%s", svoie[voie]->entmes.bid);
if (!out_disk (fptr, s))
return (0);
}
if (!out_disk (fptr, ret))
return (0);
if (!out_disk (fptr, svoie[voie]->entmes.titre))
return (0);
if (!out_disk (fptr, ret))
return (0);
deb_io ();
make_header (&(svoie[voie]->entmes), header);
entete_mess_fwd (&(svoie[voie]->entmes), header);
if (!out_disk (fptr, msg_header))
return (0);
fin_io ();
if ((f_mptr = ouvre_mess (O_TEXT, svoie[voie]->entmes.numero, svoie[voie]->entmes.status)) != NULL)
{
while (1)
{
if (fgets (buffer, 256, f_mptr) == NULL)
break;
lastchar = buffer[strlen (buffer) - 1];
if (!out_disk (fptr, lf_to_cr (buffer)))
{
ferme (f_mptr, 31);
return (0);
}
}
ferme (f_mptr, 31);
}
else
{
dde_warning (W_ASC);
sprintf (s, "\rMessage file %s missing in %s\r", pvoie->sr_fic, mycall);
if (!out_disk (fptr, s))
return (0);
}
if ((lastchar != '\n') && (!out_disk (fptr, "\r")))
return (0);
if (!out_disk (fptr, "/EX\r"))
return (0);
tst_warning (ptmes);
return (1);
}
static int out_disk (FILE * fptr, char *texte)
{
int nb = 0;
int retour;
char buffer[300];
char *optr = buffer;
aff_bas (voiecur, W_SNDT, texte, strlen (texte));
while (*texte)
{
if (*texte == '\r')
{
*optr = '\r';
++optr;
if (++nb == 300)
break;
*optr = '\n';
}
else if (*texte != '\n')
*optr = *texte;
++optr;
++texte;
if (++nb == 300)
break;
}
if (nb == 0)
return (1);
deb_io ();
retour = ((int) fwrite (buffer, nb, 1, fptr));
fin_io ();
return (retour > 0);
}
int export_message (char *nom_fich)
{
int i;
int fd;
FILE *fptr;
char temp[200];
aff_etat ('J');
aff_header (voiecur);
aff_forward ();
pvoie->lignes = -1;
pvoie->finf.lang = langue[0]->numlang;
for (i = 0; i < 2; i++)
{
/* Checks for the lock file and creates it */
fd = open (lfile (nom_fich), O_EXCL | O_CREAT, S_IREAD | S_IWRITE);
if (fd == -1)
{
#ifdef __WIN32__
long tt;
WIN32_FIND_DATA ff;
SYSTEMTIME t;
FILETIME ft;
if (errno != EEXIST)
{
sprintf (temp, "*** error : Cannot create lock file %s\r", lfile (nom_fich));
aff_bas (voiecur, W_RCVT, temp, strlen (temp));
break;
}
if (FindFirstFile ((char *) lfile (nom_fich), &ff) != (HANDLE) - 1)
{
GetSystemTime (&t);
SystemTimeToFileTime (&t, &ft);
/* Add one hour to File time (approximative) */
ff.ftLastWriteTime.dwHighDateTime += 9;
if (CompareFileTime (&ft, &ff.ftLastWriteTime) > 0L)
{
/* If more than 1 hour, delete the lock file if possible */
unlink (lfile (nom_fich));
sprintf (temp, "*** file %s was locked since more than 1 hour, lock deleted !!\r",
nom_fich);
aff_bas (voiecur, W_SNDT, temp, strlen (temp));
}
else
{
sprintf (temp, "*** file %s locked !!\r", nom_fich);
aff_bas (voiecur, W_SNDT, temp, strlen (temp));
break;
}
}
#else
/* Checks the date of the lock file */
struct stat statbuf;
long t = time (NULL);
if (errno != EEXIST)
{
sprintf (temp, "*** error : Cannot create lock file %s\r", lfile (nom_fich));
aff_bas (voiecur, W_RCVT, temp, strlen (temp));
break;
}
if ((stat (lfile (nom_fich), &statbuf) == 0) && ((t - statbuf.st_ctime) > 3600L))
{
/* If more than 1 hour, delete the lock file if possible */
unlink (lfile (nom_fich));
sprintf (temp, "*** file %s was locked from more than 1 hour (%ld), lock deleted (%ld)!!\r",
nom_fich, statbuf.st_ctime, t);
aff_bas (voiecur, W_SNDT, temp, strlen (temp));
}
else
{
sprintf (temp, "*** file %s locked !!\r", nom_fich);
aff_bas (voiecur, W_SNDT, temp, strlen (temp));
break;
}
#endif
}
else
break;
}
if (fd == -1)
{
aff_bas (voiecur, W_SNDT, "*** done\r", 9);
inexport = 0;
deconnexion (voiecur, 1);
init_etat ();
status (voiecur);
return (0);
}
close (fd);
if ((fptr = fappend (nom_fich, "b")) == NULL)
{
#ifdef ENGLISH
sprintf (temp, " File error %s ", nom_fich);
#else
sprintf (temp, "Erreur fichier %s", nom_fich);
#endif
win_message (5, temp);
aff_bas (voiecur, W_RCVT, "*** disk error !!\r", 18);
aff_bas (voiecur, W_SNDT, "*** done\r", 9);
inexport = 0;
deconnexion (voiecur, 1);
init_etat ();
status (voiecur);
unlink (lfile (nom_fich));
return (0);
}
if (mess_suiv (mail_ch))
{
if (mess_export (fptr, mail_ch, svoie[mail_ch]->entmes.date, svoie[mail_ch]->entmes.numero))
{
fin_envoi_fwd (mail_ch);
aff_bas (voiecur, W_RCVT, "Export>\r", 8);
}
else
{
fclose (fptr);
unlink (lfile (nom_fich));
#ifdef ENGLISH
sprintf (temp, " File error %s ", nom_fich);
#else
sprintf (temp, "Erreur fichier %s", nom_fich);
#endif
aff_bas (voiecur, W_RCVT, "*** disk error !!\r", 18);
aff_bas (voiecur, W_SNDT, "*** done\r", 9);
inexport = 0;
deconnexion (voiecur, 1);
/* ferme(fptr, 7) ; */
#if defined(__WINDOWS__) || defined(__linux__)
window_disconnect (voiecur);
#endif
init_etat ();
status (voiecur);
return (0);
}
}
else
{
aff_bas (voiecur, W_SNDT, "*** done\r", 9);
inexport = 0;
deconnexion (voiecur, 1);
init_etat ();
}
ferme (fptr, 7);
unlink (lfile (nom_fich));
status (voiecur);
return (1);
}
fbb-7.0.11/src/init.c 0000664 0001750 0001750 00000052615 14064410130 011154 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
/*
* INIT.C
*
*/
#include "serv.h"
static void aff_heure (void);
static void cree_tpstat (void);
static int init_dir (void);
static void init_tpstat (void);
static void initarbre (void);
static void initmessage (void);
static void start_bbs (void);
#ifdef __MSDOS__
static void init_bufscreen (Screen *);
static void val_screen (void);
#endif
extern char _video[];
#ifdef __MSDOS__
void initialisations (void)
{
int bbs_init = 1;
fprintf (stderr, "\nMSDOS defined init.c INITIALISATIONS\n");
while (!step_initialisations (bbs_init))
++bbs_init;
}
#endif
int step_initialisations (int niveau)
{
int i;
#ifdef __WINDOWS__
unsigned long dMem;
#endif
InitText ("");
/* fprintf (stderr, "FBB step_initialisations niveau:%d\n",niveau);*/
switch (niveau)
{
case 1:
{
/* Check endian */
long val = 1;
moto = (*((char *)(&val)) == '\0');
}
debug_ptr = NULL;
operationnel = -1;
h_ok = 1;
MAXTACHE = MAXTASK;
init_semaine ();
#ifdef __WINDOWS__
/* Allocation du buffer partage ... */
dMem = GlobalDosAlloc (400ul);
if (dMem == 0ul)
{
cprintf ("Can't allocate shared buffer\r\n");
exit (1);
}
BufSeg = HIWORD (dMem);
BufSel = LOWORD (dMem);
BufReel = (char far *) ((unsigned long) BufSel << 16);
#endif
sed = 1;
EditorOff = TRUE;
editor_request = 0;
errno = 0;
lastaff = -1;
reply = 0;
snd_io = 0;
through_mfilter = 1;
h_screen = 25;
bid_ptr = NULL;
log_ptr = NULL;
throute = NULL;
tbroute = NULL;
p_port = NULL;
def_cur.nbmess = def_cur.nbnew = 0;
def_cur.coord = 0xffff;
memcpy (def_cur.indic, "NULL", 5);
test_fichiers = 0;
#ifdef __MSDOS__
ton_bip = 0;
kam_timer = 0;
#endif
vlang = -1;
time_bcl = 0;
blank = 0;
nb_hold = 0;
ok_aff = 1;
aut_ui = 1;
doubl = 0;
v_aff = -1;
console = 0;
editor = 0;
cmd_fct = 0;
print = 0;
def_mask = 0;
t_tell = -1;
v_tell = 0;
ch_fen = 0;
inexport = 0;
nb_error = 0;
temp_sec = SECONDE;
d_blanc = 0;
include_size = 0;
p_forward = 0;
time_include = NULL;
mem_alloue = 0L;
t_bbs = 0L;
t_appel = 0L;
hour_time = -1;
t_iliste.suiv = NULL;
tete_fwd = NULL;
tete_serv = NULL;
tete_pg = NULL;
bbs_ptr = NULL;
p_port = NULL;
*t_iliste.indic = '\0';
p_iliste = &t_iliste;
NBVOIES = 1;
for (i = 0; i < NBLIG; i++)
af_voie[i] = -1;
#ifdef __linux__
#ifdef ENGLISH
cprintf ("Reading fbb.conf file\n");
#else
cprintf ("Lecture du fichier fbb.conf\n");
#endif
#else
#ifdef ENGLISH
cprintf ("Reading INIT.SRV\r\n");
#else
cprintf ("Lecture de INIT.SRV\r\n");
#endif
#endif
init_voie (CONSOLE); /* Init console */
voiecur = CONSOLE;
pvoie = svoie[voiecur];
if (!init_admin ())
return (0);
if (!init_dir ())
return (0);
port_log (0, 0, 'S', "I *** BBS Initialize");
deb_io ();
operationnel = 0;
window_connect (ALLCHAN);
window_connect (CONSOLE);
window_connect (MMONITOR);
free_mem ();
return 0;
case 2:
init_exms ();
initexte ();
aff_date ();
free_mem ();
ferme(ouvre_sat(), 0);
return 0;
case 3:
init_tpstat ();
free_mem ();
#ifdef __FBBDOS__
#ifdef ENGLISH
cprintf ("RS232 ports set-up \r\n");
#else
cprintf ("Initialisation des ports RS232\r\n");
#endif
#endif
#ifdef __linux__
#ifdef ENGLISH
cprintf ("RS232 ports set-up \n");
#else
cprintf ("Initialisation des ports RS232\n");
#endif
#endif
init_watchdog (watchport);
initport ();
return 0;
case 4:
initcom ();
#ifdef __FBBDOS__
#ifdef ENGLISH
cprintf ("TNC set-up \r\n");
#else
cprintf ("Initialisation des TNC\r\n");
#endif
#endif
#ifdef __linux__
#ifdef ENGLISH
cprintf ("TNC set-up \n");
#else
cprintf ("Initialisation des TNC\n");
#endif
#endif
inittnc ();
return 0;
case 5:
affich_serveurs (2);
affich_pg (2);
t_label();
free_mem ();
return 0;
case 6:
#ifdef __FBBDOS__
#ifdef ENGLISH
cprintf ("BID set-up \r\n");
#else
cprintf ("Initialisation des BID\r\n");
#endif
#endif
#ifdef __linux__
#ifdef ENGLISH
cprintf ("BID set-up \n");
#else
cprintf ("Initialisation des BID\n");
#endif
#endif
cree_bid ();
free_mem ();
return 0;
case 7:
initarbre ();
free_mem ();
return 0;
case 8:
/* epure_messages() ; */
load_dirmes ();
initmessage ();
return 0;
case 9:
if (!init_white_pages ())
cree_routes ();
else
h_ok = 0;
free_mem ();
#ifdef __FBBDOS__
#ifdef ENGLISH
cprintf ("Files set-up complete \r\n");
#else
cprintf ("Fin des initialisations Fichiers\r\n");
#endif
#endif
#ifdef __linux__
#ifdef ENGLISH
cprintf ("Files set-up complete \n");
#else
cprintf ("Fin des initialisations Fichiers\n");
#endif
#endif
return 0;
case 10:
fwd_file = NULL;
fwd_size = 0;
#ifdef __FBBDOS__
#ifdef ENGLISH
cprintf ("FORWARD set-up \r\n");
#else
cprintf ("Initialisation du forward\r\n");
#endif
#endif
#ifdef __linux__
#ifdef ENGLISH
cprintf ("FORWARD set-up \n");
#else
cprintf ("Initialisation du forward\n");
#endif
#endif
init_buf_fwd ();
init_buf_swap ();
init_buf_rej ();
return 0;
case 11:
init_bbs ();
init_part ();
free_mem ();
read_heard ();
init_etat ();
tst_appel ();
return 0;
case 12:
init_hold ();
init_pfh();
load_themes ();
#ifdef __FBBDOS__
#ifdef ENGLISH
cprintf ("Set-up complete \r\n");
#else
cprintf ("Fin des initialisations\r\n");
#endif
#endif
#ifdef __linux__
#ifdef ENGLISH
cprintf ("Set-up complete \n");
#else
cprintf ("Fin des initialisations\n");
#endif
#endif
vlang = 0;
com_error = old_com_error = 0;
aff_ind_console ();
free_mem ();
aff_date ();
aff_heure ();
fin_io ();
canaff = v_aff;
winlig = h_screen - 1 - M_LIG;
#ifdef TRACE
open_trace ();
#endif
if (*BBS_UP)
{
char *pptr = BBS_UP;
#ifdef __linux__
call_nbdos (&pptr, 1, NO_REPORT_MODE, NULL, TOOLDIR, NULL);
#else
call_nbdos (&pptr, 1, NO_REPORT_MODE, NULL, NULL, NULL);
#endif
}
start_bbs ();
return 1;
}
return 1;
}
static void start_bbs (void)
{
int port = 1;
char buffer[300];
int nb;
df ("io", 0);
deb_io ();
voiecur = 1;
type_sortie = 1;
save_fic = 0;
aff_date ();
operationnel = 1;
env_date ();
for (port = 1; port < NBPORT; port++)
{
if (p_port[port].pvalid)
{
switch (p_port[port].typort)
{
case TYP_DED:
sprintf (buffer, "H 18");
tnc_commande (port, buffer, PORTCMD);
sprintf (buffer, "H 1");
tnc_commande (port, buffer, PORTCMD);
sprintf (buffer, "H 2");
tnc_commande (port, buffer, PORTCMD);
/* Ajouter la validation des ports */
break;
case TYP_PK:
break;
}
}
}
for (nb = 1; nb < NBVOIES; nb++)
{
programm_indic (nb);
set_bs(nb, TRUE);
}
test_disque ();
sprintf (buffer, "A *** BBS Online (%s)", version());
port_log (0, 0, 'S', buffer);
/* port_log (0, 0, 'S', "A *** BBS Online");*/
fin_io ();
start_tasks ();
mem_alloue = 0L;
free_mem ();
dde_wp_serv = 1;
/* Amorce les TNCs en mode DED */
for (nb = 0; nb < NBPORT; nb++)
{
int i;
/* positionnel le mult_sel au 1er multi dans chaque COM */
for (i = 0; i < 8; i++)
{
if (p_com[nb].multi[i])
{
int port = p_com[nb].multi[i];
p_com[nb].mult_sel = port;
break;
}
}
}
ff ();
}
static int dir_found (char *dir)
{
int nb;
char path[256];
char str[256];
strcpy (path, dir);
nb = strlen (path);
if ((nb > 1) && (path[1] == ':'))
{
if ((nb > 3) && (path[nb - 1] == '\\'))
path[nb - 1] = '\0';
}
else
{
if ((nb > 1) && (path[nb - 1] == '\\'))
path[nb - 1] = '\0';
}
if (!is_dir (path))
{
sprintf (str, "Directory %s not found", back2slash (path));
ShowError ("FBB TREE", str, 0);
fbb_quit (0);
WinSleep (10);
return (0);
}
return (1);
}
static int init_dir (void)
{
/* Cree l'arbre des repertoires */
int i;
char dir[128];
/* Arborescence MAIL */
if (!dir_found (MESSDIR))
return (0);
for (i = 0; i < 10; i++)
{
sprintf (dir, "%smail%d", MESSDIR, i);
if (!dir_found (dir))
return (0);
}
/* Arborescence BINMAIL */
if (!dir_found (MBINDIR))
return (0);
for (i = 0; i < 10; i++)
{
sprintf (dir, "%smail%d", MBINDIR, i);
if (!dir_found (dir))
return (0);
}
/* Repertoire WP */
sprintf (dir, "%swp", DATADIR);
if (!dir_found (dir))
return (0);
/* Repertoire DOCS */
if (!dir_found (DOCSDIR))
return (0);
/* Repertoires DOS */
for (i = 1; i < 8; i++)
{
if (*PATH[i])
if (!dir_found (PATH[i]))
return (0);
}
/* Repertoire YAPP */
if (!dir_found (YAPPDIR))
return (0);
/* Repertoire PG */
/* if (!dir_found (PGDIR))
return (0); */
return (1);
}
void init_semaine (void)
{
long temps = time (NULL);
struct tm *sdate = localtime (&temps);
int ny = sdate->tm_yday; /* Numero du jour dans l'annee */
int nw = sdate->tm_wday; /* Numero du jour dans la semaine */
/*
if (nw == 0)
nw = 6;
else
--nw; */ /* 0 = dimanche -> 0 = lundi */
if (ny < nw) /* Premiere semaine de l'annee ? */
{
temps -= (3600L * 24L * (ny + 1));
sdate = localtime (&temps);
ny = sdate->tm_yday; /* Numero du jour de l'annee precedente */
nw = sdate->tm_wday; /* Numero du jour de la semaine avant */
/* if (nw == 0)
nw = 6;
else
--nw; */ /* 0 = dimanche -> 0 = lundi */
}
num_semaine = (7 - nw + ny) / 7;
}
void start_tasks (void)
{
trait_time = 0;
#ifdef ENGLISH
cprintf ("Starting multitasking ...");
#else
cprintf ("D‚marre le multitƒches...");
#endif
#ifdef __MSDOS__
init_keyboard ();
#endif
#ifdef __linux__
cprintf (" ok\n");
#else
cprintf (" ok\r\n");
#endif
}
void end_voies (void)
{
int i;
/* Inclut la voie Warnings (NBVOIES+1) */
for (i = 0; i < NBVOIES + 1; i++)
{
if (svoie[i])
m_libere (svoie[i], sizeof (Svoie));
}
}
void init_voie (int voie)
{
int i;
Svoie *vptr;
svoie[voie] = vptr = (Svoie *) m_alloue (sizeof (Svoie));
time_yapp[voie] = -1;
vptr->timout = time_n;
init_timout (voie);
vptr->msg_held = 0;
vptr->rzsz_pid = -1;
vptr->temp1 = vptr->mess_recu = 1;
vptr->fbb = bin_fwd;
/* vptr->wp = */ vptr->clock = '\0';
vptr->ret = 0;
vptr->sid = vptr->aut_nc = vptr->ind_mess = vptr->warning = 0;
vptr->ask = vptr->seq = vptr->dde_int = vptr->stop = 0;
vptr->mbl = vptr->sta.stat = vptr->sta.connect = vptr->deconnect = 0;
vptr->sta.mem = 32000;
vptr->sr_mem = vptr->memoc = vptr->nb_err = 0;
vptr->niv1 = vptr->niv2 = vptr->niv3 = 0;
vptr->maj_ok = vptr->conf = vptr->dde_marche = 0;
vptr->groupe = vptr->kiss = vptr->ch_mon = vptr->cross_connect = -1;
vptr->cur_bull = -1L;
vptr->localmode = vptr->binary = vptr->sta.ret = vptr->sta.ack = 0;
vptr->type_yapp = 0;
vptr->maxbuf = 8;
vptr->emis = NULL;
vptr->ctnc = NULL;
vptr->outptr = NULL;
vptr->msgtete = NULL;
vptr->l_mess = vptr->l_yapp = vptr->entmes.numero = 0L;
vptr->inbuf.nblig = vptr->inbuf.nbcar = vptr->inbuf.nocar = 0;
vptr->inbuf.tete = NULL;
vptr->inbuf.curr = NULL;
vptr->inbuf.ptr = NULL;
vptr->curfwd = NULL;
vptr->t_read = NULL;
vptr->t_list = NULL;
vptr->llabel = NULL;
vptr->r_tete = NULL;
vptr->ncur = &def_cur;
vptr->mbl_ext = 1;
vptr->nb_egal = 0;
vptr->nb_prompt = 0;
vptr->prot_fwd = prot_fwd;
vptr->tete_edit.liste = NULL;
vptr->entmes.bid[0] = '\0';
vptr->sta.callsign.call[0] = '\0';
vptr->sta.callsign.num = 0;
vptr->sta.indicatif.call[0] = '\0';
vptr->sta.indicatif.num = 0;
for (i = 0; i < 8; i++)
{
vptr->sta.relais[i].call[0] = '\0';
vptr->sta.relais[i].num = 0;
}
init_fb_mess (voie);
}
static void aff_heure (void)
{
struct tm *sdate;
long temps = time (NULL);
sdate = gmtime (&temps);
cprintf ("GMT %02d:%02d", sdate->tm_hour, sdate->tm_min);
sdate = localtime (&temps);
#ifdef __linux__
cprintf (" - LOCAL %02d:%02d\n", sdate->tm_hour, sdate->tm_min);
#else
cprintf (" - LOCAL %02d:%02d\r\n", sdate->tm_hour, sdate->tm_min);
#endif
}
void lit_appel (void)
{
FILE *fptr;
sed = 1;
fptr = fopen (d_disque ("OPTIONS.SYS"), "rb");
if (fptr)
{
fread (&bip, sizeof (short), 1, fptr);
fread (&ok_tell, sizeof (short), 1, fptr);
fread (&ok_aff, sizeof (short), 1, fptr);
fread (&separe, sizeof (short), 1, fptr);
fread (&doub_fen, sizeof (short), 1, fptr);
fread (&gate, sizeof (short), 1, fptr);
fread (&just, sizeof (short), 1, fptr);
fread (&p_forward, sizeof (short), 1, fptr);
fread (&sed, sizeof (short), 1, fptr);
fread (&aff_inexport, sizeof (short), 1, fptr);
fread (&aff_popsmtp, sizeof (short), 1, fptr);
fclose (fptr);
}
if (separe < M_LIG + 5)
separe = M_LIG + 5;
if (separe > h_screen - 4)
separe = h_screen - 4;
/* printf("%d %d %d %d %d\n", bip, ok_tell, ok_aff, separe, doub_fen) ; */
#if defined(__WINDOWS__) || defined(__linux__)
maj_menu_options ();
#endif
}
void cree_dir (int erreur)
{
bullist lbul;
FILE *fptr;
if ((fptr = fopen (d_disque ("DIRMES.SYS"), "wb")) == NULL)
{
fbb_error (ERR_CREATE, d_disque ("DIRMES.SYS"), erreur);
}
lbul.type = '\0';
lbul.numero = 100L;
fwrite (&lbul, sizeof (bullist), 1, fptr);
fclose (fptr);
}
void cree_info (void)
{
FILE *fptr;
if ((fptr = fopen (d_disque ("INF.SYS"), "wb")) == NULL)
{
fbb_error (ERR_CREATE, d_disque ("INF.SYS"), 0);
}
fclose (fptr);
}
void cree_stat (void)
{
FILE *fptr;
if ((fptr = fopen (d_disque ("statis.dat"), "wb")) == NULL)
{
fbb_error (ERR_CREATE, d_disque ("statis.dat"), 0);
}
fclose (fptr);
}
void cree_sat (void)
{
FILE *fptr;
if ((fptr = fopen (d_disque ("SAT\\SATEL.DAT"), "wb")) == NULL)
{
fbb_error (ERR_CREATE, d_disque ("SAT\\SATEL.DAT"), 0);
}
fclose (fptr);
}
static void cree_tpstat (void)
{
int i;
FILE *fichier;
if ((fichier = fopen (d_disque ("TPSTAT.SYS"), "wb")) == NULL)
{
fbb_error (ERR_CREATE, d_disque ("TPSTAT.SYS"), 0);
}
for (i = 0; i < NBRUB; i++)
stemps[i] = 0L;
fwrite ((char *) stemps, sizeof (*stemps) * NBRUB, 1, fichier);
fclose (fichier);
}
int err_ouvert (char *nomfic)
{
int c;
char s[80];
deb_io ();
#ifdef __linux__
#ifdef ENGLISH
cprintf ("Cannot open %s \n", nomfic);
#else
cprintf ("Erreur ouverture %s\n", nomfic);
#endif
#else
#ifdef ENGLISH
cprintf ("Cannot open %s \r\n", nomfic);
#else
cprintf ("Erreur ouverture %s\r\n", nomfic);
#endif
#endif
c = 0;
#ifdef ENGLISH
sprintf (s, "Creating file %s ", nomfic);
#else
sprintf (s, "Creation du fichier %s", nomfic);
#endif
if (sel_option (s, &c))
{
#ifdef __linux__
#ifdef ENGLISH
cprintf ("\rCreating file %s \n", nomfic);
#else
cprintf ("\rCreation du fichier %s\n", nomfic);
#endif
#else
#ifdef ENGLISH
cprintf ("\rCreating file %s \r\n", nomfic);
#else
cprintf ("\rCreation du fichier %s\r\n", nomfic);
#endif
#endif
}
fin_io ();
return (c);
}
static void init_tpstat (void)
{
FILE *fichier;
fichier = ouvre_stats ();
fclose (fichier);
while (TRUE)
{
if ((fichier = fopen (d_disque ("TPSTAT.SYS"), "r+b")) == NULL)
{
if (err_ouvert ("TPSTAT.SYS"))
cree_tpstat ();
else
fbb_error (ERR_CREATE, d_disque ("TPSTAT.SYS"), 0);
}
else
break;
}
fread ((char *) stemps, sizeof (*stemps) * NBRUB, 1, fichier);
fclose (fichier);
}
static void initarbre (void)
{
int offset;
int i = 0;
info buf2;
char buf[40];
FILE *fptr;
bloc_indic *bptr;
#ifdef __linux__
#ifdef ENGLISH
cprintf ("Callsign set-up \n");
#else
cprintf ("Initialisation de la nomenclature\n");
#endif
#else
#ifdef ENGLISH
cprintf ("Callsign set-up \r\n");
#else
cprintf ("Initialisation de la nomenclature\r\n");
#endif
#endif
deb_io ();
#ifdef __linux__
#ifdef ENGLISH
cprintf ("Callsigns set-up \n");
#else
cprintf ("Initialisation des indicatifs\n");
#endif
#else
#ifdef ENGLISH
cprintf ("Callsigns set-up \r\n");
#else
cprintf ("Initialisation des indicatifs\r\n");
#endif
#endif
rinfo = 0;
racine = bptr = new_bloc_info ();
offset = 0;
strcpy (bptr->st_ind[0].indic, "TOUS");
bptr->st_ind[0].nbmess = (short) 0;
bptr->st_ind[0].nbnew = (short) 0;
bptr->st_ind[0].coord = 0xffff;
++offset;
fptr = ouvre_nomenc ();
*buf2.indic.call = '\0';
while (fread ((char *) &buf2, (int) sizeof (buf2), 1, fptr))
{
if (find (buf2.indic.call))
{
if (offset == T_BLOC_INFO)
{
bptr->suiv = new_bloc_info ();
bptr = bptr->suiv;
offset = 0;
}
#ifdef __linux__
if ((i++ % 50) == 0)
{
InitText (itoa (i, buf, 10));
}
#endif
#ifdef __WINDOWS__
if ((i++ % 50) == 0)
{
InitText (itoa (i, buf, 10));
}
#endif
#ifdef __MSDOS__
if (tempo == 0)
{
cprintf ("%-6s\r\n", buf2.indic.call);
tempo = CADENCE;
}
#endif
inscoord (rinfo, &buf2, &(bptr->st_ind[offset]));
++offset;
}
++rinfo;
}
#ifdef __WINDOWS__
InitText (itoa (i, buf, 10));
#else
#ifdef __linux__
cprintf ("%-6s\n", buf2.indic.call);
#else
cprintf ("%-6s\r\n", buf2.indic.call);
#endif
#endif
ferme (fptr, 4);
fin_io ();
}
void fwd_cpy (recfwd * dest, bullist * orig)
{
int i;
dest->type = orig->type;
dest->bin = orig->bin;
dest->kb = (unsigned char) ((orig->taille + 500) / 1000);
dest->date = orig->date;
dest->nomess = orig->numero;
for (i = 0; i < NBMASK; i++)
dest->fbbs[i] = orig->fbbs[i];
strncpy (dest->bbsv, bbs_via (orig->bbsv), 6);
}
lfwd *cree_bloc_fwd (lfwd * ptr)
{
int i;
if (ptr)
{
ptr->suite = (lfwd *) m_alloue (sizeof (lfwd));
ptr = ptr->suite;
}
else
ptr = (lfwd *) m_alloue (sizeof (lfwd));
ptr->suite = NULL;
for (i = 0; i < NBFWD; i++)
ptr->fwd[i].type = '\0';
return (ptr);
}
int fwd_mask (char *masque)
{
int i;
for (i = 0; i < NBMASK; i++)
if (*masque++)
return (1);
return (0);
}
bloc_mess *new_bloc_mess (void)
{
int i;
bloc_mess *bptr = (bloc_mess *) m_alloue (sizeof (bloc_mess));
bptr->suiv = NULL;
for (i = 0; i < T_BLOC_MESS; i++)
{
bptr->st_mess[i].noenr = 0;
bptr->st_mess[i].nmess = 0L;
bptr->st_mess[i].no_indic = 0;
}
return (bptr);
}
void end_messages (void)
{
bloc_mess *bptr;
lfwd *ptr_fwd;
/* Libere la liste des forwards */
while (tete_fwd)
{
ptr_fwd = tete_fwd;
tete_fwd = tete_fwd->suite;
m_libere (ptr_fwd, sizeof (lfwd));
}
/* Libere la liste des messages */
while (tete_dir)
{
bptr = tete_dir;
tete_dir = tete_dir->suiv;
m_libere (bptr, sizeof (bloc_mess));
}
}
static void initmessage (void)
{
char buf[40];
bloc_mess *bptr;
unsigned no_indic;
unsigned offset = 0;
bullist bufdir;
unsigned rmess = 0;
char stat;
int pos, nbfwd;
int i = 0;
lfwd *ptr_fwd;
pos = nbfwd = 0;
ptr_fwd = tete_fwd = cree_bloc_fwd (NULL);
#ifdef __linux__
#ifdef ENGLISH
cprintf ("Message set-up \n");
#else
cprintf ("Initialisation des messages\n");
#endif
#else
#ifdef ENGLISH
cprintf ("Message set-up \r\n");
#else
cprintf ("Initialisation des messages\r\n");
#endif
#endif
deb_io ();
nbmess = 0;
ouvre_dir ();
read_dir (rmess++, &bufdir);
nomess = bufdir.numero;
#ifdef __linux__
#ifdef ENGLISH
cprintf ("Next message %ld \n", nomess + 1);
#else
cprintf ("Prochain message %ld\n", nomess + 1);
#endif
#else
#ifdef ENGLISH
cprintf ("Next message %ld \r\n", nomess + 1,);
#else
cprintf ("Prochain message %ld\r\n", nomess + 1);
#endif
#endif
bptr = tete_dir = new_bloc_mess ();
while (read_dir (rmess, &bufdir))
{
if (bufdir.type)
{
#ifdef __linux__
if ((i++ % 50) == 0)
{
InitText (itoa (i, buf, 10));
}
#endif
#ifdef __WINDOWS__
if ((i++ % 50) == 0)
{
InitText (itoa (i, buf, 10));
}
#endif
#ifdef __MSDOS__
if (tempo == 0)
{
cprintf ("%ld %-6s %d\r\n", bufdir.numero, bufdir.exped, nbfwd);
tempo = CADENCE;
}
#endif
if (offset == T_BLOC_MESS)
{
bptr->suiv = new_bloc_mess ();
bptr = bptr->suiv;
offset = 0;
}
no_indic = insarbre (&bufdir);
bptr->st_mess[offset].nmess = bufdir.numero;
bptr->st_mess[offset].noenr = rmess;
bptr->st_mess[offset].no_indic = no_indic;
stat = bufdir.status;
if ((stat != 'A') && (stat != 'K'))
{
++nbmess;
if ((stat != 'F') && (stat != 'X') && (stat != 'H'))
{
if ((bufdir.numero) && (fwd_mask (bufdir.fbbs)))
{
if (pos == NBFWD)
{
pos = 0;
ptr_fwd = cree_bloc_fwd (ptr_fwd);
}
fwd_cpy (&ptr_fwd->fwd[pos], &bufdir);
++pos;
++nbfwd;
}
}
else if (stat == 'H')
++nb_hold;
}
ins_iliste (&bufdir);
++offset;
}
++rmess;
}
#ifdef __WINDOWS__
InitText (itoa (i, buf, 10));
#else
#ifdef __linux__
if (bufdir.type)
{
cprintf ("%ld %-6s %d\n", bufdir.numero, bufdir.exped, nbfwd);
}
#else
if (bufdir.type)
{
cprintf ("%ld %-6s %d\r\n", bufdir.numero, bufdir.exped, nbfwd);
}
#endif
#endif
ferme_dir ();
fin_io ();
#ifdef __linux__
#ifdef ENGLISH
cprintf ("End - %d forward(s)\n", nbfwd);
#else
cprintf ("Fin - %d forward(s)\n", nbfwd);
#endif
#else
#ifdef ENGLISH
cprintf ("End - %d forward(s)\r\n", nbfwd);
#else
cprintf ("Fin - %d forward(s)\r\n", nbfwd);
#endif
#endif
}
fbb-7.0.11/src/fwdovl1.c 0000664 0001750 0001750 00000043562 13613525371 011611 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
/*
* MODULE FORWARDING OVERLAY 1
*/
#include
#define MAXNOT 10
static char *BID_STRING = "%ld_%s";
static char *ALT_STRING = "%ld-%s";
typedef struct pnot
{
int type[MAXNOT];
char texte[MAXNOT][41];
struct pnot *suite;
}
snot;
static int is_not (snot *, int, char *);
static int test_forward_nts (int);
static void libere_not (snot *);
static int nb_bbs;
long next_num (void)
{
char type;
unsigned record;
unsigned num_indic;
if (ptmes->numero == 0L)
{
ptmes->numero = ++nomess;
if ((ptmes->numero % 0x10000L) == 0)
ptmes->numero = ++nomess;
pvoie->mess_recu = 0;
insnoeud (ptmes->desti, &num_indic);
type = ptmes->type;
ptmes->type = '\0';
ouvre_dir ();
write_dir (0, ptmes);
record = length_dir ();
write_dir (record, ptmes);
ferme_dir ();
ptmes->type = type;
insmess (record, num_indic, ptmes->numero);
}
return (ptmes->numero);
}
static int host_bbs (bullist * pbull)
{
int retour = 0;
ind_noeud *pnoeud;
unsigned no_indic;
FILE *fptr;
info frec;
if ((is_serv (pbull->desti)) || (strcmp (pbull->desti, "SYSOP") == 0) || (!find (pbull->desti)))
return (2);
var_cpy (0, "\0");
if ((retour = route_wp_home (pbull)) != 0)
{
route_wp_hier (pbull);
var_cpy (0, "WP");
}
else
{
pnoeud = insnoeud (pbull->desti, &no_indic);
if (pnoeud->coord != 0xffff)
{
fptr = ouvre_nomenc ();
fseek (fptr, (long) pnoeud->coord * sizeof (frec), 0);
fread (&frec, sizeof (info), 1, fptr);
ferme (fptr, 39);
if (*frec.home)
{
strcpy (pbull->bbsv, frec.home);
retour = 1;
var_cpy (0, "H");
}
}
}
return (retour);
}
int chercher_voie (nom)
char *nom;
{
int i;
/* en sortie : -1 si nom n'est pas connecte, numero de voie si connecte */
for (i = 1; i < NBVOIES - 1; i++)
if ((svoie[i]->sta.connect) && (indcmp (svoie[i]->sta.indicatif.call, nom)))
return (i);
return (-1);
}
void make_bid (void)
{
char ligne[80];
long num;
char *bid_str = BID_STRING;
if (std_header & 1024)
bid_str = ALT_STRING;
if (!isalnum (*ptmes->bid))
{
if ((*pvoie->mess_bid) && ((std_header & 64) == 0))
strn_cpy (12, ligne, pvoie->mess_bid);
else if (pvoie->mess_num > 0L)
{
num = (pvoie->mess_num % 0x10000L);
sprintf (ligne, bid_str, num, bbs_via (pvoie->mess_home));
}
else
{
num = (ptmes->numero % 0x10000L);
sprintf (ligne, bid_str, num, mycall);
}
strn_cpy (12, ptmes->bid, ligne);
}
}
int fwd_get (char *buffer)
{
if (EMS_FWD_OK ())
{
return (read_exms_string (FORWARD, buffer));
}
if (*fwd_scan == '\032')
return (0);
while ((*buffer++ = *fwd_scan++) != '\0');
return (1);
}
#define BBS_LEN 6
static void in_bbs (char *bbs)
{
int i;
char *ptr = data;
for (i = 0; i < nb_bbs; i++)
{
if (strcmp (bbs, ptr) == 0)
return;
ptr += (BBS_LEN + 1);
}
strn_cpy (BBS_LEN, ptr, bbs);
++nb_bbs;
}
static void out_bbs (void)
{
int i;
char *ptr = data;
if (nb_bbs == 0)
out (" ?????? ", 8);
else
{
qsort ((void *) data, nb_bbs, BBS_LEN + 1, (int (*)(const void *, const void *)) strcmp);
for (i = 0; i < nb_bbs; i++)
{
out (" ", 1);
out (ptr, strlen (ptr));
ptr += (BBS_LEN + 1);
}
out (" ", 2);
}
}
int already_forw (char *masque, int nobbs)
{
return (masque[(nobbs - 1) / 8] & (1 << ((nobbs - 1) % 8)));
}
void set_bit_fwd (char *masque, int nobbs)
{
if (nobbs)
masque[(nobbs - 1) / 8] |= (1 << ((nobbs - 1) % 8));
}
void clr_bit_fwd (char *masque, int nobbs)
{
if (nobbs)
masque[(nobbs - 1) / 8] &= (~(1 << ((nobbs - 1) % 8)));
}
static int is_not (snot * t_not, int type, char *texte)
{
int nb;
char *ptr;
while (t_not)
{
for (nb = 0; nb < MAXNOT; nb++)
{
ptr = t_not->texte[nb];
if (*ptr == '\0')
break;
if ((t_not->type[nb] == type) && (strmatch (texte, ptr)))
{
return (1);
}
}
t_not = t_not->suite;
}
return (0);
}
static void libere_not (snot * t_not)
{
snot *p_not;
/* Libere la listes NOT */
while (t_not)
{
p_not = t_not->suite;
m_libere (t_not, sizeof (snot));
t_not = p_not;
}
}
void libere_route (int voie)
{
Svoie *vptr = svoie[voie];
Route *r_ptr;
while ((r_ptr = vptr->r_tete) != NULL)
{
vptr->r_tete = r_ptr->suite;
m_libere (r_ptr, sizeof (Route));
}
}
int test_forward (int valid)
{
char *pcom;
char ligne[80], combuf[80];
int nobbs = 0, type, nb, i, lig = 0;
long num;
int route = 0, fwd_ok = 0;
int not_b = 0, not_g = 0, not_h = 0;
int ping_pong = 0;
int route_bbs = 0;
char *bbs_v;
snot *t_not, *p_not;
char *bid_str = BID_STRING;
if (ptmes->type == 'T')
return (test_forward_nts (valid));
if (std_header & 1024)
bid_str = ALT_STRING;
t_not = p_not = NULL;
nb = MAXNOT;
bbs_v = bbs_via (ptmes->bbsv);
nb_bbs = 0;
rewind_fwd ();
if ((ptmes->type != 'B') && (strcmp (ptmes->desti, "SYSOP") != 0))
pvoie->messdate = 0L; /* TEST SUR LES BULLETINS */
if ((pvoie->messdate == 0L) || ((pvoie->messdate) && ((time (NULL) - pvoie->messdate) < (86400L * nb_jour_val))))
{
while (fwd_get (combuf))
{
pcom = combuf;
++lig;
switch (type = *pcom++)
{
case '!': /* Not ! */
if (!route)
break;
switch (type = *pcom++)
{
case 'B':
case 'F':
case 'G':
case 'H':
if (nb == MAXNOT)
{
if (p_not)
{
p_not->suite = (snot *) m_alloue (sizeof (snot));
p_not = p_not->suite;
}
else
{
t_not = p_not = (snot *) m_alloue (sizeof (snot));
}
for (i = 0; i < MAXNOT; i++)
*(p_not->texte[i]) = '\0';
p_not->suite = NULL;
nb = 0;
}
p_not->type[nb] = type;
strn_cpy (40, p_not->texte[nb], pcom);
++nb;
break;
}
break;
case 'A': /* recuperer le No et le nom de la BBS destinataire */
route = 0;
route_bbs = 0;
nobbs = num_bbs (pcom);
if (is_route (pcom))
{
set_bit_fwd (ptmes->forw, nobbs);
break;
}
strcpy (ligne, pcom);
if (already_forw (ptmes->forw, nobbs))
break;
route = 1;
libere_not (t_not);
t_not = p_not = NULL;
nb = MAXNOT;
not_b = not_g = not_h = 0;
break;
case 'G': /* indication de groupe */
if (!route)
break;
route_bbs = 0;
if ((*bbs_v) && (ptmes->status == '$'))
{
if ((not_g) || (is_not (t_not, type, bbs_v)))
{
not_g = 1;
}
else if (strmatch (bbs_v, pcom))
{
if (indcmp (pvoie->sta.indicatif.call, ligne) == 0)
{
if (!(FOR (pvoie->mode)))
{
in_bbs (ligne);
}
set_bit_fwd (ptmes->fbbs, nobbs);
fwd_ok = 1;
}
else
{
set_bit_fwd (ptmes->forw, nobbs);
}
}
}
break;
case 'H': /* indication de Hierarchie */
if (!route)
break;
route_bbs = 0;
if ((*ptmes->bbsv) && (ptmes->status != '$'))
{
if ((not_h) || (is_not (t_not, type, ptmes->bbsv)))
{
not_h = 1;
}
else if (strmatch (ptmes->bbsv, pcom))
{
if (((pvoie->mode & F_FOR) == 0) ||
(indcmp (pvoie->sta.indicatif.call, ligne) == 0))
{
set_bit_fwd (ptmes->fbbs, nobbs);
fwd_ok = 1;
if (!(FOR (pvoie->mode)))
{
in_bbs (ligne);
}
}
else
{ /* Ping Pong ! */
/* dde_warning(W_PPG); */
ping_pong = 1;
}
}
}
break;
case 'B': /* indication de BBS */
if (!route)
break;
route_bbs = 1;
if ((*bbs_v) && (ptmes->status != '$'))
{
if ((not_b) || (is_not (t_not, type, bbs_v)))
{
not_b = 1;
}
else if (strmatch (bbs_v, pcom))
{
if (((pvoie->mode & F_FOR) == 0) ||
(indcmp (pvoie->sta.indicatif.call, ligne) == 0))
{
set_bit_fwd (ptmes->fbbs, nobbs);
fwd_ok = 1;
if (!(FOR (pvoie->mode)))
{
in_bbs (ligne);
}
}
else
{ /* Ping Pong ! */
/* dde_warning(W_PPG); */
ping_pong = 1;
}
}
}
break;
case 'F': /* indication de routage */
if (!route)
break;
if (is_not (t_not, type, pcom))
break;
if ((*bbs_v == '\0') && (find (ptmes->desti)))
{
/* Redirection d'un destinataire prive */
if ((!not_b) && (strmatch (ptmes->desti, pcom)))
{
if (((pvoie->mode & F_FOR) == 0) ||
(indcmp (pvoie->sta.indicatif.call, ligne) == 0))
{
set_bit_fwd (ptmes->fbbs, nobbs);
fwd_ok = 1;
if (!(FOR (pvoie->mode)))
{
in_bbs (ligne);
}
}
else
{ /* Ping Pong ! */
/* dde_warning(W_PPG); */
ping_pong = 1;
}
}
}
else if (route_bbs == 0)
{
/* Routage sur le destinataire */
if ((!not_b) && (strmatch (ptmes->desti, pcom)))
{
if (indcmp (pvoie->sta.indicatif.call, ligne) == 0)
{
set_bit_fwd (ptmes->fbbs, nobbs);
fwd_ok = 1;
if (!(FOR (pvoie->mode)))
{
in_bbs (ligne);
}
}
}
}
break;
default:
break;
}
}
}
else
{
ptmes->status = 'X';
}
if (*(ptmes->bid) == '\0')
strcpy (ptmes->bid, " ");
if (!FOR (pvoie->mode))
{
if (fwd_ok)
{
texte (T_MBL + 40);
out_bbs ();
}
}
if ((valid) && (*ptmes->bid))
{
if (*ptmes->bid == ' ')
{
if ((*pvoie->mess_bid) && ((std_header & 64) == 0))
strn_cpy (12, ptmes->bid, pvoie->mess_bid);
else if (pvoie->mess_num > 0L)
{
num = (pvoie->mess_num % 0x10000L);
sprintf (ligne, bid_str, num, bbs_via (pvoie->mess_home));
}
else
{
num = (ptmes->numero % 0x10000L);
sprintf (ligne, bid_str, num, mycall);
}
strn_cpy (12, ptmes->bid, ligne);
}
if (!FOR (pvoie->mode))
{
if (ptmes->type == 'P')
out ("Mid: $R ", 9);
else
out ("Bid: $R ", 9);
}
if (valid == 1)
w_bid ();
}
if ((ping_pong) && (!fwd_ok))
dde_warning (W_PPG);
libere_not (t_not);
libere_route (voiecur);
return (fwd_ok);
}
static int test_forward_nts (int valid)
{
char *pcom;
char desti[80], ligne[80], combuf[80];
/* char wtexte[256] ; */
int nobbs = 0, type, nb, i, lig = 0;
long num;
int route = 0, fwd_ok = 0;
int not_z = 0;
int ping_pong = 0;
snot *t_not, *p_not;
char *bid_str = BID_STRING;
if (std_header & 1024)
bid_str = ALT_STRING;
t_not = p_not = NULL;
nb = MAXNOT;
strcpy (desti, ptmes->desti);
rewind_fwd ();
if ((pvoie->messdate == 0L) || ((pvoie->messdate) && ((time (NULL) - pvoie->messdate) < (86400L * nb_jour_val))))
{
while (fwd_get (combuf))
{
pcom = combuf;
++lig;
switch (type = *pcom++)
{
case '!': /* Not ! */
if (!route)
break;
switch (type = *pcom++)
{
case 'Z':
if (nb == MAXNOT)
{
if (p_not)
{
p_not->suite = (snot *) m_alloue (sizeof (snot));
p_not = p_not->suite;
}
else
{
t_not = p_not = (snot *) m_alloue (sizeof (snot));
}
for (i = 0; i < MAXNOT; i++)
*(p_not->texte[i]) = '\0';
p_not->suite = NULL;
nb = 0;
}
p_not->type[nb] = type;
strn_cpy (40, p_not->texte[nb], pcom);
++nb;
break;
}
break;
case 'A': /* recuperer le No et le nom de la BBS destinataire */
route = 0;
nobbs = num_bbs (pcom);
if (is_route (pcom))
{
set_bit_fwd (ptmes->forw, nobbs);
break;
}
strcpy (ligne, pcom);
if (already_forw (ptmes->forw, nobbs))
break;
route = 1;
libere_not (t_not);
t_not = p_not = NULL;
nb = MAXNOT;
not_z = 0;
break;
case 'Z': /* indication de route */
if (!route)
break;
if ((not_z) || (is_not (t_not, type, desti)))
{
not_z = 1;
}
else if (strmatch (desti, pcom))
{
if (((pvoie->mode & F_FOR) == 0) ||
(indcmp (pvoie->sta.indicatif.call, ligne) == 0))
{
set_bit_fwd (ptmes->fbbs, nobbs);
fwd_ok = 1;
if (!(FOR (pvoie->mode)))
{
in_bbs (ligne);
}
}
else
{ /* Ping Pong ! */
ping_pong = 1;
}
}
break;
default:
break;
}
}
}
else
{
ptmes->status = 'X';
}
if (!FOR (pvoie->mode))
{
if (fwd_ok)
{
texte (T_MBL + 40);
out_bbs ();
}
}
if (*(ptmes->bid) == '\0')
strcpy (ptmes->bid, " ");
if ((valid) && (!FOR (pvoie->mode)))
out (" ", 2);
if ((valid) && (*ptmes->bid))
{
if (*ptmes->bid == ' ')
{
if ((*pvoie->mess_bid) && ((std_header & 64) == 0))
strn_cpy (12, ptmes->bid, pvoie->mess_bid);
else if (pvoie->mess_num > 0L)
{
num = (pvoie->mess_num % 0x10000L);
sprintf (ligne, bid_str, num, bbs_via (pvoie->mess_home));
}
else
{
num = (ptmes->numero % 0x10000L);
sprintf (ligne, bid_str, num, mycall);
}
strn_cpy (12, ptmes->bid, ligne);
}
if (!FOR (pvoie->mode))
{
if (ptmes->type == 'P')
out ("Mid: $R ", 9);
else
out ("Bid: $R ", 9);
}
if (valid != 2)
w_bid ();
}
if ((ping_pong) && (!fwd_ok))
dde_warning (W_PPG);
libere_not (t_not);
libere_route (voiecur);
return (fwd_ok);
}
int reacheminement (void)
{
/* static int boucle = 0;*/
int achemine_trouve;
int nts_trouve;
int route_bbs;
int type = 0;
int nb;
int i;
char *pcom;
char combuf[80];
char ligne[257];
char desti[10];
char *bbs_v;
int not_b = 0, not_g = 0, not_h = 0, not_z = 0;
snot *t_not, *p_not;
df ("reacheminement", 0);
pvoie->warning = 0;
route_bbs = 0;
t_not = p_not = NULL;
nb = MAXNOT;
strcpy (desti, ptmes->desti);
bbs_v = bbs_via (ptmes->bbsv);
if (hiecmp (mypath, ptmes->bbsv))
{
*ptmes->bbsv = '\0';
ff ();
return (1);
}
/* S'il y a une route est specifiee, l'acheminement existe-t-il ? */
achemine_trouve = (*ptmes->bbsv == '\0');
nts_trouve = (ptmes->type != 'T');
if (!nts_trouve)
{
/* L'acheminement est trouve, routage sur le desti ... */
achemine_trouve = TRUE;
}
else if (achemine_trouve)
{
switch (host_bbs (ptmes))
{
case 2:
break;
case 1:
if ((!FOR (pvoie->mode)) && (ptmes->type != 'B') && (*ptmes->bbsv))
texte (T_MBL + 41);
/* l'acheminement existe-t-il pour le home BBS ? */
achemine_trouve = 0;
break;
case 0:
if ((!FOR (pvoie->mode)) && (EMS_WPG_OK ()) && (find (ptmes->desti)) && (*ptmes->bbsv == '\0'))
texte (T_MBL + 56);
}
}
if (hiecmp (mypath, ptmes->bbsv))
{
*ptmes->bbsv = '\0';
ff ();
return (1);
}
if (cherche_route (ptmes))
{
if (!FOR (pvoie->mode))
{
texte (T_MBL + 41);
}
}
bbs_v = bbs_via (ptmes->bbsv);
rewind_fwd ();
while (fwd_get (combuf))
{
pcom = combuf;
switch (*pcom++)
{
case '!': /* Not ! */
switch (type = *pcom++)
{
case 'B':
case 'G':
case 'H':
case 'Z':
case 'F':
if (nb == MAXNOT)
{
if (p_not)
{
p_not->suite = (snot *) m_alloue (sizeof (snot));
p_not = p_not->suite;
}
else
{
t_not = p_not = (snot *) m_alloue (sizeof (snot));
}
for (i = 0; i < MAXNOT; i++)
*(p_not->texte[i]) = '\0';
p_not->suite = NULL;
nb = 0;
}
p_not->type[nb] = type;
strn_cpy (40, p_not->texte[nb], pcom);
++nb;
break;
}
break;
case 'A':
route_bbs = 0;
libere_not (t_not);
t_not = p_not = NULL;
nb = MAXNOT;
not_b = not_g = not_h = not_z = 0;
case 'B': /* recuperer le nom de la BBS destinataire */
route_bbs = 1;
strcpy (ligne, pcom);
if ((not_b) || (is_not (t_not, type, bbs_v)))
{
not_b = 1;
break;
}
if ((ptmes->status != '$') && (!achemine_trouve) && (strmatch (bbs_v, pcom)))
{
achemine_trouve = TRUE;
}
break;
case 'H': /* test des hierarchies */
route_bbs = 0;
if ((not_h) || (is_not (t_not, type, bbs_v)))
{
not_h = 1;
break;
}
if ((ptmes->status != '$') && (!achemine_trouve) && (strmatch (ptmes->bbsv, pcom)))
{
achemine_trouve = TRUE;
}
break;
case 'G': /* test du groupe */
route_bbs = 0;
if ((not_g) || (is_not (t_not, type, bbs_v)))
{
not_g = 1;
break;
}
if ((ptmes->status == '$') && (!achemine_trouve) && (strmatch (bbs_v, pcom)))
{
achemine_trouve = TRUE;
}
break;
case 'Z': /* Route NTS */
route_bbs = 1;
if ((not_z) || (is_not (t_not, type, desti)))
{
not_z = 1;
break;
}
if ((ptmes->type == 'T') && (!nts_trouve) && (strmatch (desti, pcom)))
nts_trouve = TRUE;
break;
case 'F': /* chercher les messages de l'OM associe a la BBS */
if (is_not (t_not, type, pcom))
break;
if ((*(ptmes->bbsv) == '\0') && (strmatch (ptmes->desti, pcom)))
{
/* (indcmp(ptmes->desti, pcom))) { */
if ((route_bbs) && (find (ptmes->desti)))
{
strcpy (ptmes->bbsv, ligne);
}
achemine_trouve = TRUE;
if (cherche_route (ptmes))
{
if ((!FOR (pvoie->mode)) && (ptmes->type != 'B'))
{
texte (T_MBL + 41);
}
}
}
break;
default:
break;
}
}
libere_not (t_not);
if (!achemine_trouve)
{
dde_warning (W_ROU);
if (!FOR (pvoie->mode))
texte (T_MBL + 49);
}
if (!nts_trouve)
{
dde_warning (W_NTS);
if (!FOR (pvoie->mode))
{
strcpy (ligne, ptmes->bbsv);
strcpy (ptmes->bbsv, desti);
texte (T_MBL + 49);
strcpy (ptmes->bbsv, ligne);
}
}
ff ();
/* boucle = 0;*/
return (1);
}
fbb-7.0.11/src/arbre.c 0000664 0001750 0001750 00000016640 13613525371 011317 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
/*
* ARBRE.C
*
*/
#include
static void aff_ind (char *, char *);
void end_arbre (void)
{
bloc_indic *bptr;
iliste *temp;
iliste *c_iliste = t_iliste.suiv;
/* Libere l'arbre des indicatifs */
while (racine)
{
bptr = racine;
racine = racine->suiv;
m_libere (bptr, sizeof (bloc_indic));
}
/* Libere la liste des indicatifs balise */
while (c_iliste)
{
temp = c_iliste;
c_iliste = c_iliste->suiv;
m_libere (temp, sizeof (iliste));
}
t_iliste.suiv = NULL;
}
ind_noeud *insnoeud (char *indic_om, unsigned *no_indic)
{
int i;
int trouve = 0;
char om[10];
char *ptr_om = om;
int offset = 0;
unsigned num_ind = 0;
bloc_indic *bptr = racine;
static ind_noeud *pnoeud;
i = 0;
while ((*ptr_om++ = *indic_om++) != '\0')
{
if (i++ == 9)
{
*ptr_om = '\0';
break;
}
}
while (bptr)
{
pnoeud = &(bptr->st_ind[offset]);
if (*(pnoeud->indic) == '\0')
break;
if (strncmp (om, pnoeud->indic, 6) == 0)
{
trouve = 1;
break;
}
if (++offset == T_BLOC_INFO)
{
if (!bptr->suiv)
bptr->suiv = new_bloc_info ();
bptr = bptr->suiv;
offset = 0;
}
++num_ind;
}
if (!trouve)
{
n_cpy (6, pnoeud->indic, om);
pnoeud->coord = 0xffff;
pnoeud->nbmess = (short) 0;
pnoeud->nbnew = (short) 0;
pnoeud->val = 1;
}
*no_indic = num_ind;
return (pnoeud);
}
/*
* Pointe sur le dernier bloc
*/
bloc_mess *last_dir ()
{
bloc_mess *temp = tete_dir;
while (temp->suiv)
temp = temp->suiv; /* aller au dernier bloc */
return (temp);
}
/*
* Pointe sur le bloc precedent
*/
bloc_mess *prec_dir (bloc_mess * bptr)
{
bloc_mess *temp = tete_dir;
while (temp->suiv)
{
if (temp->suiv == bptr)
return (temp);
temp = temp->suiv;
}
return (NULL);
}
/*
* Insere un message dans la liste de directory
*/
int insmess (unsigned r, unsigned num_ind, long numero)
{
int i;
bloc_mess *temp = tete_dir;
while (temp->suiv)
temp = temp->suiv; /* aller au dernier bloc */
for (i = 0; ((i < T_BLOC_MESS) && (temp->st_mess[i].nmess)); i++)
;
if (i == T_BLOC_MESS)
{
temp->suiv = new_bloc_mess ();
temp = temp->suiv;
i = 0;
}
temp->st_mess[i].nmess = numero;
temp->st_mess[i].noenr = r;
temp->st_mess[i].no_indic = num_ind;
return (1);
}
/*
* Cherche un message deja insere dans la liste de directory
*/
mess_noeud *findmess (long numero)
{
int i;
bloc_mess *temp = tete_dir;
if (numero == 0L)
return (NULL);
while (temp->suiv)
{
if (temp->suiv->st_mess[0].nmess > numero)
break;
temp = temp->suiv;
}
for (i = 0; i < T_BLOC_MESS; i++)
{
if (temp->st_mess[i].nmess == numero)
return (&temp->st_mess[i]);
}
return (NULL);
}
/*
* Valide un message deja insere dans la liste de directory
*/
void valmess (bullist * bptr)
{
mess_noeud *mptr;
if ((mptr = findmess (bptr->numero)) != NULL)
{
ouvre_dir ();
write_dir (mptr->noenr, bptr);
ferme_dir ();
insarbre (bptr);
}
}
/*
* Change le numero du destinataire d'un message dans la liste de directory
*/
void chg_mess (unsigned num_ind, long numero)
{
mess_noeud *mptr;
if ((mptr = findmess (numero)) != NULL)
mptr->no_indic = num_ind;
}
unsigned insarbre (bullist * pbuf)
{
char temp[2];
unsigned no_indic;
ind_noeud *noeud;
if ((pbuf->status == 'A') || (pbuf->status == 'K'))
return (0xffff);
if (isdigit (pbuf->type))
{
temp[0] = pbuf->type;
temp[1] = '\0';
noeud = insnoeud (temp, &no_indic);
}
else
{
noeud = insnoeud (pbuf->desti, &no_indic);
}
if (pbuf->status != 'H')
{
++(noeud->nbmess);
if (pbuf->status == 'N')
++(noeud->nbnew);
}
return (no_indic);
}
void inscoord (unsigned r, info * pbuf, ind_noeud * pnoeud)
{
char om[80];
char *indic_om = pbuf->indic.call;
char *ptr_om = om;
if ((isdigit (*indic_om)) && (strlen (indic_om) == 1))
{
strcpy (om, indic_om);
}
else
{
while ((*ptr_om++ = *indic_om++) != '\0');
}
n_cpy (6, pnoeud->indic, om);
pnoeud->coord = r;
pnoeud->val = (uchar) (EXC (pbuf->flags) == 0);
pnoeud->nbmess = (short) 0;
pnoeud->nbnew = (short) 0;
}
void connexion (int voie)
{
svoie[voie]->ncur = insnoeud (svoie[voie]->sta.indicatif.call, &(svoie[voie]->no_indic));
aff_nbsta ();
}
ind_noeud *cher_noeud (char *indic_om)
{
int trouve = 0;
int offset = 0;
bloc_indic *bptr = racine;
ind_noeud *pnoeud = NULL;
while (bptr)
{
pnoeud = &(bptr->st_ind[offset]);
if (*(pnoeud->indic) == '\0')
break;
if (strncmp (indic_om, pnoeud->indic, 6) == 0)
{
trouve = 1;
break;
}
if (++offset == T_BLOC_INFO)
{
bptr = bptr->suiv;
offset = 0;
}
}
if (!trouve)
pnoeud = NULL;
return (pnoeud);
}
unsigned chercoord (char *indic_om)
{
ind_noeud *noeud = cher_noeud (indic_om);
if (noeud)
return (noeud->coord);
else
return (0xffff);
}
/*
* Liste des destinataires prives -> balise
*/
void ins_iliste (bullist * buf)
{
int cmp;
iliste *temp, *prec;
iliste *c_iliste = &t_iliste;
if ((*buf->bbsv) && (!hiecmp (mypath, buf->bbsv)))
return;
if (buf->status == 'H')
return;
if ((buf->type == 'P') && (buf->status != 'N'))
return;
if (strcmp (buf->desti, "WP") == 0)
return;
if ((buf->type != 'P') && (
(balbul == 0) ||
(buf->status == 'X') || (buf->status == 'K') || (buf->status == 'A')
))
return;
prec = c_iliste;
while ((c_iliste = c_iliste->suiv) != NULL)
{
cmp = strcmp (c_iliste->indic, buf->desti);
if (cmp == 0)
return;
if (cmp > 0)
break;
prec = c_iliste;
}
temp = (iliste *) m_alloue (sizeof (iliste));
prec->suiv = temp;
temp->suiv = c_iliste;
strcpy (temp->indic, buf->desti);
}
void list_new (char *chaine)
{
iliste *prec;
int flag_l, nombre = max_indic;
ind_noeud *noeud;
unsigned num_indic;
*chaine = '\0';
flag_l = FALSE;
while (nombre)
{
if (t_iliste.suiv == NULL)
break;
prec = p_iliste;
if (p_iliste == &t_iliste)
flag_l = TRUE;
p_iliste = p_iliste->suiv;
if (p_iliste == NULL)
{
p_iliste = &t_iliste;
if (flag_l)
break;
continue;
}
noeud = insnoeud (p_iliste->indic, &num_indic);
if (noeud->nbnew == 0)
{
prec->suiv = p_iliste->suiv;
m_libere (p_iliste, sizeof (iliste));
p_iliste = prec;
continue;
}
aff_ind (noeud->indic, chaine);
nombre--;
}
if (*chaine == '\0')
strcpy (chaine, " None");
}
static void aff_ind (char *indptr, char *indch)
{
strcat (indch, " ");
strcat (indch, indptr);
}
bloc_indic *new_bloc_info (void)
{
int i;
bloc_indic *bptr = (bloc_indic *) m_alloue (sizeof (bloc_indic));
bptr->suiv = NULL;
for (i = 0; i < T_BLOC_INFO; i++)
*(bptr->st_ind[i].indic) = '\0';
return (bptr);
}
fbb-7.0.11/src/md5c.c 0000664 0001750 0001750 00000025626 13613525371 011060 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by
F6FBB - Jean-Paul ROUBELAT
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
/* MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
*/
/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
rights reserved.
License to copy and use this software is granted provided that it
is identified as the "RSA Data Security, Inc. MD5 Message-Digest
Algorithm" in all material mentioning or referencing this software
or this function.
License is also granted to make and use derivative works provided
that such works are identified as "derived from the RSA Data
Security, Inc. MD5 Message-Digest Algorithm" in all material
mentioning or referencing the derived work.
RSA Data Security, Inc. makes no representations concerning either
the merchantability of this software or the suitability of this
software for any particular purpose. It is provided "as is"
without express or implied warranty of any kind.
These notices must be retained in any copies of any part of this
documentation and/or software.
*/
#include "global.h"
#include "md5.h"
/* Constants for MD5Transform routine.
*/
#define S11 7
#define S12 12
#define S13 17
#define S14 22
#define S21 5
#define S22 9
#define S23 14
#define S24 20
#define S31 4
#define S32 11
#define S33 16
#define S34 23
#define S41 6
#define S42 10
#define S43 15
#define S44 21
static void MD5Transform PROTO_LIST ((UINT4[4], uchar[64]));
static void Encode PROTO_LIST
((uchar *, UINT4 *, unsigned int));
static void Decode PROTO_LIST
((UINT4 *, uchar *, unsigned int));
static void MD5_memcpy PROTO_LIST ((POINTER, POINTER, unsigned int));
static void MD5_memset PROTO_LIST ((POINTER, int, unsigned int));
static uchar PADDING[64] =
{
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
/* F, G, H and I are basic MD5 functions.
*/
#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define I(x, y, z) ((y) ^ ((x) | (~z)))
/* ROTATE_LEFT rotates x left n bits.
*/
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
Rotation is separate from addition to prevent recomputation.
*/
#define FF(a, b, c, d, x, s, ac) { \
(a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define GG(a, b, c, d, x, s, ac) { \
(a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define HH(a, b, c, d, x, s, ac) { \
(a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define II(a, b, c, d, x, s, ac) { \
(a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
/* MD5 initialization. Begins an MD5 operation, writing a new context.
*/
void MD5Init (context)
MD5_CTX *context; /* context */
{
context->count[0] = context->count[1] = 0;
/* Load magic initialization constants.
*/
context->state[0] = 0x67452301L;
context->state[1] = 0xefcdab89L;
context->state[2] = 0x98badcfeL;
context->state[3] = 0x10325476L;
}
/* MD5 block update operation. Continues an MD5 message-digest
operation, processing another message block, and updating the
context.
*/
void MD5Update (context, input, inputLen)
MD5_CTX *context; /* context */
uchar *input; /* input block */
unsigned int inputLen; /* length of input block */
{
unsigned int i, index, partLen;
/* Compute number of bytes mod 64 */
index = (unsigned int) ((context->count[0] >> 3) & 0x3F);
/* Update number of bits */
if ((context->count[0] += ((UINT4) inputLen << 3))
< ((UINT4) inputLen << 3))
context->count[1]++;
context->count[1] += ((UINT4) inputLen >> 29);
partLen = 64 - index;
/* Transform as many times as possible.
*/
if (inputLen >= partLen)
{
MD5_memcpy
((POINTER) & context->buffer[index], (POINTER) input, partLen);
MD5Transform (context->state, context->buffer);
for (i = partLen; i + 63 < inputLen; i += 64)
MD5Transform (context->state, &input[i]);
index = 0;
}
else
i = 0;
/* Buffer remaining input */
MD5_memcpy
((POINTER) & context->buffer[index], (POINTER) & input[i],
inputLen - i);
}
/* MD5 finalization. Ends an MD5 message-digest operation, writing the
the message digest and zeroizing the context.
*/
void MD5Final (digest, context)
uchar digest[16]; /* message digest */
MD5_CTX *context; /* context */
{
uchar bits[8];
unsigned int index, padLen;
/* Save number of bits */
Encode (bits, context->count, 8);
/* Pad out to 56 mod 64.
*/
index = (unsigned int) ((context->count[0] >> 3) & 0x3f);
padLen = (index < 56) ? (56 - index) : (120 - index);
MD5Update (context, PADDING, padLen);
/* Append length (before padding) */
MD5Update (context, bits, 8);
/* Store state in digest */
Encode (digest, context->state, 16);
/* Zeroize sensitive information.
*/
MD5_memset ((POINTER) context, 0, sizeof (*context));
}
/* MD5 basic transformation. Transforms state based on block.
*/
static void MD5Transform (state, block)
UINT4 state[4];
uchar block[64];
{
UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
Decode (x, block, 64);
/* Round 1 */
FF (a, b, c, d, x[0], S11, 0xd76aa478L); /* 1 */
FF (d, a, b, c, x[1], S12, 0xe8c7b756L); /* 2 */
FF (c, d, a, b, x[2], S13, 0x242070dbL); /* 3 */
FF (b, c, d, a, x[3], S14, 0xc1bdceeeL); /* 4 */
FF (a, b, c, d, x[4], S11, 0xf57c0fafL); /* 5 */
FF (d, a, b, c, x[5], S12, 0x4787c62aL); /* 6 */
FF (c, d, a, b, x[6], S13, 0xa8304613L); /* 7 */
FF (b, c, d, a, x[7], S14, 0xfd469501L); /* 8 */
FF (a, b, c, d, x[8], S11, 0x698098d8L); /* 9 */
FF (d, a, b, c, x[9], S12, 0x8b44f7afL); /* 10 */
FF (c, d, a, b, x[10], S13, 0xffff5bb1L); /* 11 */
FF (b, c, d, a, x[11], S14, 0x895cd7beL); /* 12 */
FF (a, b, c, d, x[12], S11, 0x6b901122L); /* 13 */
FF (d, a, b, c, x[13], S12, 0xfd987193L); /* 14 */
FF (c, d, a, b, x[14], S13, 0xa679438eL); /* 15 */
FF (b, c, d, a, x[15], S14, 0x49b40821L); /* 16 */
/* Round 2 */
GG (a, b, c, d, x[1], S21, 0xf61e2562L); /* 17 */
GG (d, a, b, c, x[6], S22, 0xc040b340L); /* 18 */
GG (c, d, a, b, x[11], S23, 0x265e5a51L); /* 19 */
GG (b, c, d, a, x[0], S24, 0xe9b6c7aaL); /* 20 */
GG (a, b, c, d, x[5], S21, 0xd62f105dL); /* 21 */
GG (d, a, b, c, x[10], S22, 0x2441453L); /* 22 */
GG (c, d, a, b, x[15], S23, 0xd8a1e681L); /* 23 */
GG (b, c, d, a, x[4], S24, 0xe7d3fbc8L); /* 24 */
GG (a, b, c, d, x[9], S21, 0x21e1cde6L); /* 25 */
GG (d, a, b, c, x[14], S22, 0xc33707d6L); /* 26 */
GG (c, d, a, b, x[3], S23, 0xf4d50d87L); /* 27 */
GG (b, c, d, a, x[8], S24, 0x455a14edL); /* 28 */
GG (a, b, c, d, x[13], S21, 0xa9e3e905L); /* 29 */
GG (d, a, b, c, x[2], S22, 0xfcefa3f8L); /* 30 */
GG (c, d, a, b, x[7], S23, 0x676f02d9L); /* 31 */
GG (b, c, d, a, x[12], S24, 0x8d2a4c8aL); /* 32 */
/* Round 3 */
HH (a, b, c, d, x[5], S31, 0xfffa3942L); /* 33 */
HH (d, a, b, c, x[8], S32, 0x8771f681L); /* 34 */
HH (c, d, a, b, x[11], S33, 0x6d9d6122L); /* 35 */
HH (b, c, d, a, x[14], S34, 0xfde5380cL); /* 36 */
HH (a, b, c, d, x[1], S31, 0xa4beea44L); /* 37 */
HH (d, a, b, c, x[4], S32, 0x4bdecfa9L); /* 38 */
HH (c, d, a, b, x[7], S33, 0xf6bb4b60L); /* 39 */
HH (b, c, d, a, x[10], S34, 0xbebfbc70L); /* 40 */
HH (a, b, c, d, x[13], S31, 0x289b7ec6L); /* 41 */
HH (d, a, b, c, x[0], S32, 0xeaa127faL); /* 42 */
HH (c, d, a, b, x[3], S33, 0xd4ef3085L); /* 43 */
HH (b, c, d, a, x[6], S34, 0x4881d05L); /* 44 */
HH (a, b, c, d, x[9], S31, 0xd9d4d039L); /* 45 */
HH (d, a, b, c, x[12], S32, 0xe6db99e5L); /* 46 */
HH (c, d, a, b, x[15], S33, 0x1fa27cf8L); /* 47 */
HH (b, c, d, a, x[2], S34, 0xc4ac5665L); /* 48 */
/* Round 4 */
II (a, b, c, d, x[0], S41, 0xf4292244L); /* 49 */
II (d, a, b, c, x[7], S42, 0x432aff97L); /* 50 */
II (c, d, a, b, x[14], S43, 0xab9423a7L); /* 51 */
II (b, c, d, a, x[5], S44, 0xfc93a039L); /* 52 */
II (a, b, c, d, x[12], S41, 0x655b59c3L); /* 53 */
II (d, a, b, c, x[3], S42, 0x8f0ccc92L); /* 54 */
II (c, d, a, b, x[10], S43, 0xffeff47dL); /* 55 */
II (b, c, d, a, x[1], S44, 0x85845dd1L); /* 56 */
II (a, b, c, d, x[8], S41, 0x6fa87e4fL); /* 57 */
II (d, a, b, c, x[15], S42, 0xfe2ce6e0L); /* 58 */
II (c, d, a, b, x[6], S43, 0xa3014314L); /* 59 */
II (b, c, d, a, x[13], S44, 0x4e0811a1L); /* 60 */
II (a, b, c, d, x[4], S41, 0xf7537e82L); /* 61 */
II (d, a, b, c, x[11], S42, 0xbd3af235L); /* 62 */
II (c, d, a, b, x[2], S43, 0x2ad7d2bbL); /* 63 */
II (b, c, d, a, x[9], S44, 0xeb86d391L); /* 64 */
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
/* Zeroize sensitive information.
*/
MD5_memset ((POINTER) x, 0, sizeof (x));
}
/* Encodes input (UINT4) into output (unsigned char). Assumes len is
a multiple of 4.
*/
static void Encode (output, input, len)
uchar *output;
UINT4 *input;
unsigned int len;
{
unsigned int i, j;
for (i = 0, j = 0; j < len; i++, j += 4)
{
output[j] = (uchar) (input[i] & 0xff);
output[j + 1] = (uchar) ((input[i] >> 8) & 0xff);
output[j + 2] = (uchar) ((input[i] >> 16) & 0xff);
output[j + 3] = (uchar) ((input[i] >> 24) & 0xff);
}
}
/* Decodes input (unsigned char) into output (UINT4). Assumes len is
a multiple of 4.
*/
static void Decode (output, input, len)
UINT4 *output;
uchar *input;
unsigned int len;
{
unsigned int i, j;
for (i = 0, j = 0; j < len; i++, j += 4)
output[i] = ((UINT4) input[j]) | (((UINT4) input[j + 1]) << 8) |
(((UINT4) input[j + 2]) << 16) | (((UINT4) input[j + 3]) << 24);
}
/* Note: Replace "for loop" with standard memcpy if possible.
*/
static void MD5_memcpy (output, input, len)
POINTER output;
POINTER input;
unsigned int len;
{
unsigned int i;
for (i = 0; i < len; i++)
output[i] = input[i];
}
/* Note: Replace "for loop" with standard memset if possible.
*/
static void MD5_memset (output, value, len)
POINTER output;
int value;
unsigned int len;
{
unsigned int i;
for (i = 0; i < len; i++)
((char *) output)[i] = (char) value;
}
fbb-7.0.11/src/sysinfo.c 0000664 0001750 0001750 00000007310 14077313004 011701 0000000 0000000 /************************************************************************
Copyright (C) 1986-2000 by Jean-Paul Roubelat (F6FBB)
Copyright (C) 2000-2020 by Bernard Pidoux (F6BVP)
Copyright (C) 2020-2021 by Dave van der Locht
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 3 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, see .
Parts of code have been taken from many other softwares.
Thanks for the help.
************************************************************************/
/*
* This code is slightly modified from the procps package.
*/
#include
#include
#include
#include
#include
#include
#include
#include "sysinfo.h"
#define UPTIME_FILE "/proc/uptime"
#define LOADAVG_FILE "/proc/loadavg"
#define MEMINFO_FILE "/proc/meminfo"
static char buf[800];
/* This macro opens FILE only if necessary and seeks to 0 so that successive
calls to the functions are more efficient. It also reads the current
contents of the file into the global buf.
*/
#define FILE_TO_BUF(FILE) { \
static int n, fd = -1; \
if (fd == -1 && (fd = open(FILE, O_RDONLY)) == -1) { \
fprintf(stderr, "%s %d\n", FILE, errno); \
close(fd); \
return 0; \
} \
lseek(fd, 0L, SEEK_SET); \
if ((n = read(fd, buf, sizeof buf - 1)) < 0) { \
fprintf(stderr, "%s %d\n", FILE, errno); \
close(fd); \
fd = -1; \
return 0; \
} \
buf[n] = '\0'; \
}
#define SET_IF_DESIRED(x,y) if (x) *(x) = (y) /* evals 'x' twice */
int uptime(double *uptime_secs, double *idle_secs) {
double up=0, idle=0;
FILE_TO_BUF(UPTIME_FILE)
if (sscanf(buf, "%lf %lf", &up, &idle) < 2)
{
fprintf(stderr, "Bad data in " UPTIME_FILE "\n");
return 0;
}
SET_IF_DESIRED(uptime_secs, up);
SET_IF_DESIRED(idle_secs, idle);
return up; /* assume never be zero seconds in practice */
}
int loadavg(double *av1, double *av5, double *av15) {
double avg_1=0, avg_5=0, avg_15=0;
FILE_TO_BUF(LOADAVG_FILE)
if (sscanf(buf, "%lf %lf %lf", &avg_1, &avg_5, &avg_15) < 3) {
fprintf(stderr, "Bad data in " LOADAVG_FILE "\n");
return 0;
}
SET_IF_DESIRED(av1, avg_1);
SET_IF_DESIRED(av5, avg_5);
SET_IF_DESIRED(av15, avg_15);
return 1;
}
/* The following /proc/meminfo parsing routine assumes the following format:
[