static int
janus_wait(int lmodem)
{
/* FIXME: erkennt Protokollfehler nicht */
char c;
fprintf(stderr, "....\n");
alarm(10*60);
do {
while (read(lmodem, &c, 1) != 1) {
newlog(DEBUGLOG,
"can't read from modem: %s", strerror(errno));
return 1;
}
} while (c != NAK);
alarm(0);
fprintf(stderr, "Gegenseite hat gepackt\n");
alarm(15);
do {
write(lmodem, "UNIXD", 5);
while (read(lmodem, &c, 1) != 1) {
newlog(DEBUGLOG,
"can't read from modem: %s", strerror(errno));
return 1;
}
} while (c != ACK);
alarm(0);
fprintf(stderr, "Seriennummern OK\n");
return 0;
}
/** dialstring bauen, Default: AT DT */
static int
make_dialstr(char *dialstr, size_t maxlen, char *intntl)
{
/* input:
dialstr: Zielstring
maxlen: max. Laenge desselben
phone: Rufnummer
* return:
0: Erfolg
-1: Ueberlauf
-2: kein %s im Config-Dialstring
*/
int rc;
char phone[60], telno[60], vorw[60], country[60];
header_p p;
while (*intntl && !isspace(*intntl))
intntl++;
while (*intntl && isspace(*intntl))
intntl++;
setup_dial_info(intntl, country, vorw, telno);
if (strcmp(country, g_int_prefix) == 0) {
/* nationaler Anruf */
if (strcmp(vorw, g_ovst) == 0) {
/* lokaler Anruf */
rc = snprintf(phone, sizeof(phone), "%s", telno);
} else {
rc = snprintf(phone, sizeof(phone), "%s%s%s",
fernwahl, vorw, telno);
}
} else {
/* internationaler Anruf */
rc = snprintf(phone, sizeof(phone), "%s%s%s%s",
international ? international:"00",
country, vorw, telno);
}
if (rc < 0) return -1;
p = find(HD_MODEM_DIAL, config);
if(p && !strstr(p->text, "%s")) {
newlog(ERRLOG, "Konfiguration hat kein %%s im Dialstring!");
dialstr[0]='\0';
return -2;
}
rc = snprintf(dialstr, maxlen,
p ? p->text : "AT DT %s",
phone);
return rc < 0 ? rc : 0;
}
static void
anrufdauer( void )
{
time_t now;
if ( online_start == 0 )
return;
time(&now);
newlog(logname,
#ifdef ENABLE_DIFFTIME
"Anrufdauer: ca. %g Sekunden online",
difftime(now, online_start));
#else
"Anrufdauer: ca. %ld Sekunden online",
(long)(now-online_start));
#endif
online_start = 0;
}
int
backup3(const char *backupdir, const char *file,
const char *sysname, const char *arcer)
{
int rc = -1;
if ( file == NULL )
return rc;
if ( backupdir != NULL ) {
if ( backupnumber ) {
return backup2( backupdir, file, sysname, arcer );
};
rc = backup( backupdir, file, sysname, BACKUP_LINK );
};
if(remove(file) && errno != ENOENT) {
newlog(ERRLOG,
"cannot remove file %s: %s",
file, strerror(errno));
rc = 1;
}
return rc;
}
/* -------------------------------------------------------------------- */
void newUser(char *initials, char *password)
{
label fullnm;
char InitPw[80];
char Initials[80];
char passWord[80];
char *semicolon;
int lines;
int abort, good = 0;
char firstime = 1;
if (!CARRIER) return;
unlisted = FALSE; /* default to [Y] for list in userlog for new users */
roomtell = TRUE; /* default to [Y] for display of room descriptions */
/* this only initializes log.buf, does not write it out */
if (newlog() == ERROR) return;
logBuf.linesScreen = cfg.linesScreen;
/* askTerm(); */
configure(TRUE); /* make sure new users configure reasonably */
lines = logBuf.linesScreen;
tutorial("password.blb");
do
{
do
{
/* getNormStr("full name", fullnm, NAMESIZE, ECHO); */
enterName(cfg.enter_name, fullnm, NULL);
if ( (personexists(fullnm) != ERROR )
|| (strcmpi(fullnm, "Sysop") == SAMESTRING)
|| (strcmpi(fullnm, "Aide") == SAMESTRING)
|| !strlen(fullnm) )
{
mPrintf("We already have a %s\n", fullnm);
good = FALSE;
}
else (good = TRUE);
}
while(!good && CARRIER);
if (!CARRIER) return;
if (firstime)
{
strcpy(Initials, initials);
}
else
{
getNormStr("your initials", InitPw, 40, NO_ECHO);
dospCR();
semicolon = strchr(InitPw, ';');
if( semicolon )
{
normalizepw(InitPw, Initials, passWord);
}
else
{
strcpy(Initials, InitPw);
}
/* dont allow anything over 19 characters */
Initials[19] = '\0';
}
do
{
if (firstime)
{
strcpy(passWord, password);
}
else if (!semicolon)
{
getNormStr("password", passWord, NAMESIZE, NO_ECHO);
dospCR();
}
firstime = FALSE; /* keeps from going in infinite loop */
semicolon = FALSE;
if ( pwexists(passWord) != ERROR || strlen(passWord) < 2)
{
good = FALSE;
mPrintf("\n Poor password\n ");
}
else good = TRUE;
}
while( !good && CARRIER );
displaypw(fullnm, Initials, passWord);
abort = getYesNo("OK",2);
if (abort == 2) return; /* check for Abort at (Y/N/A)[A]: */
}
while ( (!abort) && CARRIER);
if (CARRIER)
{
/* Moved from newlog() */
strcpy(logBuf.lbname, fullnm);
strcpy(logBuf.lbin, Initials);
strcpy(logBuf.lbpw, passWord);
/* This stuff moved from newlog()
time(&logBuf.calltime);
setsysconfig();
/*
* trap it
*/
sprintf( msgBuf->mbtext, "New user %s", logBuf.lbname);
if (onConsole)
strcat(msgBuf->mbtext, " (Console)");
trap(msgBuf->mbtext, T_LOGIN);
loggedIn = TRUE;
slideLTab(thisSlot);
storeLog();
/* End of stuff moved from newlog() */
}
logBuf.linesScreen = (uchar)lines;
}
/* backup
* inputs:
*
*
* returns:
* 0: okay
* 1: error during execution
* 2: not a regular file
* 3: file not found
* -1: file, backup or sysname have been NULL or an illegal backup_type
* has been specified
*/
int
backup(const char *backupdir, const char *file,
const char *sysname, enum backup_type backup_type)
{
logcwd("backup");
if (backupdir && file && sysname) {
char backupname[FILENAME_MAX];
const char *shortname, *btype;
int rc;
struct stat st;
if(lstat(file, &st)) {
newlog(ERRLOG, "backup: cannot stat %s: %s",
file, strerror(errno));
return 3;
}
if(!S_ISREG(st.st_mode)) {
newlog(ERRLOG,
"backup: %s is not a regular file, mode: 0%o",
file, st.st_mode);
return 2;
}
shortname = strrchr(file, '/');
if (!shortname) shortname = file;
else shortname++;
snprintf(backupname, sizeof(backupname),
"%s/%s.%s.%ld",
backupdir, sysname,
shortname, (long)time(NULL));
newlog(DEBUGLOG, "Backup: %s -> %s\n", file, backupname);
if(remove(backupname) && errno != ENOENT) {
newlog(ERRLOG,
"cannot remove backup destination %s: %s",
backupname, strerror(errno));
return 1;
}
switch(backup_type) {
case BACKUP_MOVE:
rc=rename(file, backupname);
btype="mv";
break;
case BACKUP_LINK:
rc=link(file, backupname);
btype="ln";
break;
default:
return -1;
}
if(rc) {
newlog(ERRLOG,
"cannot backup: %s %s %s: %s",
btype, file, backupname,
strerror(errno));
return 1;
} else {
return 0;
}
}
return -1;
}
int
backup2(const char *backupdir, const char *file,
const char *sysname, const char *arcer)
{
char backupname[FILENAME_MAX];
char backupnamenew[FILENAME_MAX];
long i;
long backupnr;
struct stat st;
if ( backupdir == NULL )
return -1;
if ( file == NULL )
return -1;
if ( sysname == NULL )
return -1;
if ( arcer == NULL )
arcer = "non";
if(lstat(file, &st)) {
newlog(ERRLOG, "backup: cannot stat %s: %s",
file, strerror(errno));
return 3;
}
if(!S_ISREG(st.st_mode)) {
newlog(ERRLOG,
"backup: %s is not a regular file, mode: 0%o",
file, st.st_mode);
return 2;
}
if (backupnumber == NULL) {
backupnr = 5;
newlog(ERRLOG,
"Warnung: Backup-Zahl ist nicht definiert.");
} else {
backupnr = atoi(backupnumber);
if (backupnr < 1) {
backupnr = 5;
newlog(ERRLOG,
"Warnung: Backup-Zahl ist 0. Nehme stattdessen 5.");
}
}
/* Rotieren */
for (i = (backupnr-1);i > 0;i--) {
snprintf(backupname,sizeof(backupname),
"%s/%s.%ld.%s",
backupdir, sysname, i, arcer );
snprintf(backupnamenew,sizeof(backupnamenew),
"%s/%s.%ld.%s",
backupdir, sysname, i+1, arcer );
/* Wenns die Datei nicht gibt,
oder sie eine normale Datei ist, ok */
if ( lstat(backupnamenew,&st) != ENOENT ) {
if (!S_ISREG(st.st_mode) ) {
snprintf(backupname,sizeof(backupname)-1,
"%s/%s.%ld.%s",
backupdir, sysname,
(long)time(NULL), arcer );
newlog(ERRLOG,
"Backup: Fehler %s ist keine regulaere Datei."
" Speichere Backup unter %s",
backupnamenew, backupname );
break;
}
}
newlog(DEBUGLOG,"rename: %s -> %s",backupname,backupnamenew);
rename(backupname,backupnamenew);
}
/* Wenn die Schleife durch ist,
steht in backupname system.1.arcer, oder
backupname hat einen Wert auf den geschrieben werden kann */
newlog(DEBUGLOG,"rename %s -> %s",file,backupname);
rename(file,backupname);
return 0;
}
int
anruf( header_p sys, header_p ich, int lmodem, int tries )
{
char dialstr[80];
char lockname[FILENAME_MAX];
header_p p;
char *name, *pw;
const char **v;
int i, err;
int dial_cnt = 1;
/* fuer Janus */
char *arcer=NULL, *arcerin=NULL, *transfer=NULL, *domain;
header_p t, d;
int netcall_error;
char filename[FILENAME_MAX];
char tmpname[FILENAME_MAX];
char outname[FILENAME_MAX];
char inname[FILENAME_MAX];
char sysname[FILENAME_MAX];
struct stat st;
/* ende fuer Janus */
t = find(HD_ARCEROUT, sys);
if (!t) {
newlog(ERRLOG,
"Kein ausgehender Packer definiert");
return 1;
}
arcer = t->text;
strlwr(arcer);
t = find(HD_ARCERIN, sys);
if (!t) {
newlog(ERRLOG,
"Kein eingehender Packer definiert");
return 1;
}
arcerin = t->text;
strlwr(arcerin);
t = find(HD_PROTO, sys);
if (!t) {
newlog(ERRLOG,
"Kein Uebertragungsprotokoll definiert");
return 1;
}
transfer = t->text;
strlwr(transfer);
name = NULL;
p = find(HD_SYS, ich);
if (p) name = p->text;
pw = NULL;
p = find(HD_PASSWD, sys);
if (p) pw = p->text;
p = find(HD_X_CALL, sys);
if (!p) {
fprintf(stderr, "Welches Netcall-Verfahren????\n");
exit(20);
}
for (i = 0, v = verf; *v; i++, v++)
if (stricmp(*v, p->text) == 0)
break;
if (!*v) return 1;
if (i < ZCONNECT) {
t = find(HD_SYS, sys);
if (!t) {
newlog(ERRLOG,
"Illegale Systemdatei: Kein " HN_SYS
": Header oder falscher Name: %s", filename);
return 1;
}
d = find(HD_DOMAIN, sys);
if (!d) {
newlog(ERRLOG,
"Illegale Systemdatei: Kein " HN_DOMAIN
": Header: %s", filename);
return 1;
}
for (domain = strtok(d->text, " ;,:");
domain;
domain = strtok(NULL, " ;,:")) {
sprintf(sysname, "%s.%s", t->text, domain);
strlwr(sysname);
sprintf(tmpname, "%s/%s", netcalldir, sysname);
newlog(logname,
"Suche Verzeichnis, versuche %s...", tmpname);
if (access(tmpname, R_OK|X_OK) == 0)
break;
}
if(access(tmpname, R_OK|X_OK)) {
/* Problem: temp. Verzeichnis nicht zu haben */
newlog(logname,
"Problem beim Netcall: Verzeichnis "
"nicht gefunden");
return 1;
}
}
/* ##### HIER WIRD ANGEWAEHLT ##### */
p = find(HD_TEL, sys);
while(tries) {
if(!p) p = find(HD_TEL, sys);
make_dialstr(dialstr, sizeof(dialstr), p->text);
fprintf(stderr, "%3d. Anwahlversuch (noch %d): %-.25s\n",
dial_cnt++, tries, dialstr);
if (redial(dialstr, lmodem, 1) != 0 ) {
tries--;
p = p->other;
} else {
/* connect */
break;
}
}
set_local(lmodem, 0);
time(&online_start);
if (i < ZCONNECT) {
if (name) dfree(name);
name = dstrdup(boxstat.boxname);
strupr(name);
#ifdef ENABLE_CAPS_IN_PASSWORD
strupr(pw);
#endif
}
if(login(lmodem, i, name, pw)) return 0;
if (i < ZCONNECT) { /* JANUS */
int have_file = 0;
netcall_error = 0;
if ( janus_wait(lmodem) != 0 )
return 0;
sprintf(tmpname, "%s/%s.%d.dir", netcalldir, sysname, getpid());
mkdir(tmpname, 0755);
chdir(tmpname);
/* outname: ausgehendes Archiv
* filename: */
sprintf(outname, "%s/caller.%s", tmpname, arcer);
sprintf(filename, "%s/%s.%s", netcalldir, sysname, arcer);
sprintf(lockname, "%s/%s/" PREARC_LOCK, netcalldir, sysname);
if (access(filename, R_OK) != 0) {
FILE *f;
if(access(filename, F_OK) == 0) {
newlog(ERRLOG,
"Leerer Puffer, weil keine Erlaubnis "
"zum Lesen von %s: %s",
outname, strerror(errno));
}
f = fopen(outname, "wb");
if (!f) {
newlog(ERRLOG,
"Kann Netcall %s nicht erzeugen: %s",
outname, strerror(errno));
fclose(deblogfile);
return 1;
}
fputs("\r\n", f);
fclose(f);
} else { /* can read filename */
if (waitnolock(lockname, 180)) {
fclose(deblogfile);
newlog(OUTGOING, "System %s Prearc LOCK: %s",
sysname, lockname );
return 1;
}
fprintf(stderr, "Link: %s -> %s\n",
filename, outname);
if(link(filename, outname)) {
fclose(deblogfile);
newlog(ERRLOG,
"Linken: %s -> %s fehlgeschlagen: %s",
filename, outname, strerror(errno));
netcall_error = 1;
goto finish;
}
have_file = 1;
}
sprintf(inname, "called.%s", arcer);
st.st_size = 0;
if(stat(outname, &st)) {
fprintf(stderr,
"Zugriff auf %s fehlgeschlagen: %s\n",
outname, strerror(errno));
netcall_error = 1;
goto finish;
}
newlog(logname, "Sende %s (%ld Bytes) per %s",
outname, (long)st.st_size, transfer);
err = sendfile(transfer, outname);
if (err) {
newlog(logname,
"Versand der Daten fehlgeschlagen");
netcall_error = 1;
goto finish;
}
newlog(logname, "Empfange mit %s", transfer);
if (recvfile(transfer, inname)) {
newlog(logname,
"Empfang der Daten fehlgeschlagen");
netcall_error = 1;
goto finish;
}
st.st_size = 0;
if(stat(inname, &st)) {
newlog(logname,
"Zugriff auf %s fehlgeschlagen: %s",
inname, strerror(errno));
}
newlog(logname, "%ld Bytes empfangen", (long)st.st_size);
finish:
/* Fertig, Modem auflegen */
signal(SIGHUP, SIG_IGN);
fclose(stdin);
fclose(stdout);
hayes_hangup(lmodem); DMLOG("hayes hangup modem");
hangup(lmodem); DMLOG("hangup modem");
anrufdauer();
restore_linesettings(lmodem);
DMLOG("restoring modem parameters");
close(lmodem); lmodem=-1; DMLOG("close modem");
/* neuer stdin */
fopen("/dev/null", "r");
/* stderr wird in stdout kopiert */
dup2(fileno(stderr),fileno(stdout));
if(!netcall_error) {
/* Netcall war erfolgreich, also Daten loeschen */
if(have_file) {
/* Backups von Nullpuffern sind
uninteressant */
backup3(backoutdir,filename,sysname,arcer);
}
/* das ist nur ein Link, den putzen wir weg */
if ( unlink(outname)) {
newlog(ERRLOG,
"Loeschen von %s fehlgeschlagen: %s",
outname, strerror(errno));
}
fclose(deblogfile);
/*
* Und empfangene Daten (im Hintergrund) einlesen,
* das Modem wird sofort wieder freigegeben.
*/
switch(fork()) {
case -1:
{ /* cannot fork */
perror("forking import");
newlog(ERRLOG,
"Forken des Importteils "
"fehlgeschlagen: %s",
strerror(errno));
break;
}
case 0:
{
/* Ich bin child */
deblogfile=fopen("/tmp/import.deblogfile", "a");
DMLOG("child forked");
import_all(arcerin, sysname);
chdir ("/");
if(rmdir(tmpname)) {
newlog(ERRLOG,
"Loeschen von %s "
"fehlgeschlagen: %s",
tmpname, strerror(errno));
}
fclose(deblogfile);
exit(0);
}
default: /* parent */
break;
}
}
return(1);
} else {
/* ZCONNECT */
system_master(ich, sys);
if (auflegen) return 1;
bereitstellen();
files = 1;
senden_queue = todo;
todo = NULL;
while (!auflegen) {
datei_master(ich, sys);
}
anrufdauer();
close(lmodem); DMLOG("close modem");
aufraeumen();
exit (0);
}
return 1;
}
int
main(int argc, const char **argv)
{
const char *sysname, *speed;
char sysfile[FILENAME_MAX];
char deblogname[FILENAME_MAX];
FILE *f;
header_p sys, ich, p;
int i;
initlog("call");
if (0 == strcmp(argv[0], "-h")) usage();
if (argc < 4 || argc > 5) usage();
gmodem=-1;
atexit(cleanup);
sysname = strlwr( dstrdup( argv[1] ));
if (!strchr(argv[2], '/'))
snprintf(tty, sizeof(tty), "/dev/%s", argv[2]);
else
strcpy(tty, argv[2]);
speed = argv[3];
maxtry = 1;
if (argc > 4)
maxtry = atoi(argv[4]);
minireadstat();
sprintf(deblogname, "%s/" DEBUGLOG_FILE, logdir);
if(debuglevel>0) {
deblogfile = fopen(deblogname, "w");
if (!deblogfile) {
printf("Ich kann das Logfile nicht oeffnen. "
"Probiere /dev/null...\n");
deblogfile = fopen("/dev/null", "w");
if (!deblogfile) {
printf("Hmm... - /dev/null "
"nicht schreibbar??\n");
return 10;
}
}
} else {
deblogfile = fopen("/dev/null", "w");
if (!deblogfile) {
printf("Arghl! - kann /dev/null "
"nicht zum Schreiben oeffnen!\n\n");
return 10;
}
}
sprintf(sysfile, "%s/%s", systemedir, sysname);
f = fopen(sysfile, "r");
if (!f) {
perror(sysfile);
newlog(ERRLOG, "File <%s> not readable: %s",
sysfile, strerror(errno));
return 1;
}
sys = rd_para(f);
fclose(f);
ich = get_myself();
for (i=maxtry; i; i--) {
if (lock_device(1, tty)) break;
fputs(" ... unser Modem ist belegt\n", stderr);
sleep(60);
}
if (!i) {
newlog(ERRLOG, "Cannot lock device: %s", tty);
return 9;
}
#ifdef LEAVE_CTRL_TTY
/*
* Bisheriges Controlling-TTY verlassen, damit "modem" das neue
* wird.
*/
#ifdef BSD
setpgrp(0, getpid()); /* set process group id to process id */
#ifdef SIGTTOU
signal(SIGTTOU, SIG_IGN);
#endif
#ifdef SIGTTIN
signal(SIGTTIN, SIG_IGN);
#endif
#ifdef SIGTSTP
signal(SIGTSTP, SIG_IGN);
#endif
#else /* !BSD */
#if !defined(USE_SETSID) && !defined(USE_SETPGRP)
#error Controlling TTY kann nicht verlassen werden: definieren Sie eine Methode dazu
#endif /* !BSD und keine SysV-Methode definiert */
#ifdef USE_SETSID
#error Dies funktioniert nicht!
setsid();
#endif /* USE_SETSID */
#ifdef USE_SETPGRP
setpgrp();
#endif /* USE_SETPGRP */
#endif /* !BSD */
#endif /* LEAVE_CTRL_TTY */
gmodem = open(tty,
#if !defined(__NetBSD__)
O_RDWR | O_NDELAY
#else
O_RDWR
#endif
); DMLOG("open modem");
if (gmodem < 0) {
newlog(ERRLOG,
"Can not access device %s: %s", tty, strerror(errno));
return 10;
}
#if !defined(__NetBSD__)
else {
/* Nonblock abschalten */
int n;
n=fcntl(gmodem, F_GETFL, 0);
(void)fcntl(gmodem, F_SETFL, n & ~O_NDELAY);
}
#endif
save_linesettings(gmodem); DMLOG("saving modem parameters");
set_rawmode(gmodem); DMLOG("set modem to rawmode");
set_local(gmodem, 1);
set_speed(gmodem, speed); DMLOG("set modem speed");
#ifdef TIOCSCTTY
ioctl(gmodem, TIOCSCTTY, NULL);
#endif
files = 0;
online_start = 0;
fprintf(stderr, "Netcall bei %s [%s]\n", sysname, tty);
fclose(stdin);
fclose(stdout);
dup(gmodem); dup(gmodem); DMLOG("dup modem 2x to stdin and stdout");
if (setjmp(timeout)) {
newlog(ERRLOG, "ABBRUCH: Timeout");
lock_device(0, tty);
anrufdauer();
if (files) aufraeumen();
return 11;
}
if (setjmp(nocarrier)) {
if (!auflegen) {
newlog(ERRLOG, "ABBRUCH: Gegenstelle hat aufgelegt");
}
lock_device(0, tty);
anrufdauer();
if (files) aufraeumen();
return auflegen ? 0 : 12;
}
signal(SIGHUP, handle_nocarrier);
signal(SIGALRM, handle_timeout);
setup_dial_info(ortsnetz, g_int_prefix, g_ovst, NULL);
p = find(HD_TEL, sys);
if (!p) {
newlog(ERRLOG,
"Keine Telefonnummer fuer %s gefunden",
sysname);
return 2;
}
anruf(sys, ich, gmodem, maxtry);
if (online_start) {
anrufdauer();
} else {
fprintf(stderr, "Keine Verbindung hergestellt.\n");
}
lock_device(0, tty);
/* Device ist freigegeben, aber wir warten noch auf das Ende
der Importphase, bevor wir zurueckkehren. */
wait(NULL);
return 0;
}
