rsalz@bbn.com (Rich Salz) (05/19/88)
Submitted-by: fthood!egray
Posting-number: Volume 14, Issue 102
Archive-name: pcomm/part04
#! /bin/sh
# This is a shell archive, meaning:
# 1. Remove everything above the #! /bin/sh line.
# 2. Save the resulting text in a file.
# 3. Execute the file with /bin/sh (not csh) to create:
# input.c
# line_set.c
# list_dir.c
# ls_menu.c
# m_lib.c
# main.c
# n_shell.c
# p_lib.c
# pexit.c
# port.c
# redial.c
export PATH; PATH=/bin:/usr/bin:$PATH
echo shar: "extracting 'input.c'" '(6599 characters)'
if test -f 'input.c'
then
echo shar: "will not over-write existing file 'input.c'"
else
sed 's/^X//' << \SHAR_EOF > 'input.c'
X/*
X * The input routines. These routines are run as a child process to the
X * main pcomm program.
X */
X
X#define LPR "/usr/bin/lpr"
X
X#define MAX_ROW 64
X#define MAX_COL 128
X
X#include <stdio.h>
X#include <signal.h>
X#include <setjmp.h>
X
Xjmp_buf i_jmp;
Xunsigned char vs[MAX_ROW][MAX_COL+2];
Xint row, col;
X
X/*
X * Read the serial port and write the characters to the screen. Watch
X * for signals from the parent process to toggle the fancy options.
X * Writes the characters received to a virtual screen buffer.
X */
Xint
Xinput(fd, add_lf, log, print, max_row, max_col, vs_file, log_file)
Xint fd, add_lf, log, print, max_row, max_col;
Xchar *vs_file, *log_file;
X{
X FILE *logfp, *lprfp, *popen();
X int hold, skip_row, got_sig();
X unsigned char c;
X char lf=10;
X void _exit();
X /* set the trap for the signals */
X signal(SIGALRM, SIG_IGN);
X signal(SIGUSR1, got_sig);
X signal(SIGUSR2, got_sig);
X signal(SIGINT, got_sig);
X signal(SIGTERM, got_sig);
X /* resonable limits */
X if (max_row > MAX_ROW)
X max_row = MAX_ROW;
X if (max_col > MAX_COL)
X max_col = MAX_COL;
X /* read previous screen */
X if (!access(vs_file, 0)) {
X read_vs(vs_file, max_row, max_col);
X skip_row = 0;
X }
X else
X skip_row = 1;
X
X hold = 0;
X /* startup file pointers */
X if (print)
X lprfp = popen(LPR, "w");
X
X if (log && strcmp(log_file, "NOT_DEFINED"))
X logfp = fopen(log_file, "a");
X
X switch(setjmp(i_jmp)) {
X case 0: /* no signal */
X break;
X case 1: /* toggle the data logging */
X signal(SIGUSR1, got_sig);
X if (!strcmp(log_file, "NOT_DEFINED")) {
X log = 0;
X break;
X }
X log = log ? 0 : 1;
X if (log)
X logfp = fopen(log_file, "a");
X else
X fclose(logfp);
X break;
X case 2: /* toggle the printer */
X signal(SIGUSR2, got_sig);
X print = print ? 0 : 1;
X if (print)
X lprfp = popen(LPR, "w");
X else {
X putc(014, lprfp);
X pclose(lprfp);
X }
X break;
X case 3: /* suspend the input */
X signal(SIGINT, got_sig);
X hold = hold ? 0 : 1;
X if (hold)
X write_vs(vs_file, max_row, max_col);
X break;
X case 4: /* cleanup and go home */
X signal(SIGTERM, got_sig);
X if (log)
X fclose(logfp);
X if (print) {
X putc(014, lprfp);
X pclose(lprfp);
X }
X _exit(0);
X break;
X }
X /* any signal will awaken pause() */
X if (hold)
X pause();
X /* clear if vs_path doesn't exist */
X if (access(vs_file, 0))
X clear_vs(max_row, max_col);
X /*
X * The very first screen we see after dialing has the "Connected to..."
X * message at row 0, therefore we start our virtual screen at row 1.
X */
X if (skip_row) {
X skip_row = 0;
X row = 1;
X }
X
X while(1) {
X if (read(fd, (char *) &c, 1) <= 0)
X continue;
X /* send to logfile */
X if (log) {
X if (c == 015 && add_lf)
X fwrite(&lf, 1, 1, logfp);
X /* no carriage returns in logfile */
X if (c != 015)
X fwrite((char *) &c, 1, 1, logfp);
X }
X /* send to printer too ? */
X if (print)
X fwrite((char *) &c, 1, 1, lprfp);
X
X /* put a char in virtual screen */
X putchar_vs(c, add_lf, max_row, max_col);
X
X write(1, (char *) &c, 1);
X /* add LF to CR ? */
X if (add_lf)
X write(1, &lf, 1);
X }
X}
X
X/*
X * Figure out which signal we just received, and fix the return code of
X * the setjmp function above to the proper value.
X */
X
Xint
Xgot_sig(sig)
Xint sig;
X{
X void longjmp();
X
X switch(sig) {
X case SIGUSR1:
X longjmp(i_jmp, 1);
X case SIGUSR2:
X longjmp(i_jmp, 2);
X case SIGINT:
X longjmp(i_jmp, 3);
X case SIGTERM:
X longjmp(i_jmp, 4);
X }
X}
X
X/*
X * Put a character in the virtual screen. This routine saves incoming
X * character in a two dimensional buffer designed to mimic the real
X * screen. CURRENTLY DOES NOT UNDERSTAND ESCAPE SEQUENCES!
X */
X
Xint
Xputchar_vs(c, add_lf, max_row, max_col)
Xunsigned char c;
Xint add_lf, max_row, max_col;
X{
X int tab_stop;
X
X switch(c) {
X case 8: /* destructive back space */
X col--;
X if (col < 0)
X col = 0;
X vs[row][col] = ' ';
X break;
X case 9: /* tab character */
X tab_stop = col + 8 - (col % 8);
X /* if wrap around */
X if (tab_stop >= max_col) {
X /* spaces up to eol */
X for (; col<max_col; col++)
X vs[row][col] = ' ';
X row++;
X if (row >= max_row)
X scroll_vs(max_row, max_col);
X
X /* the remainder of the tab */
X col = tab_stop - max_col;
X }
X else {
X for (; col<tab_stop; col++)
X vs[row][col] = ' ';
X }
X break;
X case 13: /* carriage return */
X col = 0;
X if (!add_lf)
X break;
X /* fall thru...*/
X case 10: /* line feed */
X row++;
X if (row >= max_row)
X scroll_vs(max_row, max_col);
X break;
X default: /* a normal character */
X vs[row][col] = c;
X col++;
X /* wrap around */
X if (col >= max_col) {
X col = 0;
X row++;
X if (row >= max_row)
X scroll_vs(max_row, max_col);
X }
X break;
X }
X return;
X}
X
X/*
X * Save the virtual screen to a file.
X */
X
Xint
Xwrite_vs(vs_file, max_row, max_col)
Xchar *vs_file;
Xint max_row, max_col;
X{
X FILE *fp;
X int i;
X
X if (!(fp = fopen(vs_file, "w")))
X return(1);
X /* current x y coordinates */
X fprintf(fp, "%d,%d\n", row, col);
X
X for (i=0; i<max_row; i++) {
X vs[i][max_col] = NULL;
X fprintf(fp, "%s\n", vs[i]);
X }
X fclose(fp);
X return(0);
X}
X
X/*
X * Get the virtual screen image from the file. Since input() gets
X * killed from time to time, the vs_path file is the only way to retain
X * the screen image.
X */
X
Xint
Xread_vs(vs_file, max_row, max_col)
Xchar *vs_file;
Xint max_row, max_col;
X{
X FILE *fp;
X int i;
X char buf[10];
X /* in case the fopen fails... */
X row = 0;
X col = 0;
X /* not guaranteed to exist yet */
X if (!(fp = fopen(vs_file, "r")))
X return(1);
X /* get the x, y coordinates */
X fgets(buf, 10, fp);
X scanf(buf, "%d,%d\n", &row, &col);
X
X /* read the file into the vs array */
X for (i=0; i<max_row; i++) {
X fgets((char *) vs[i], MAX_COL+2, fp);
X vs[i][max_col] = NULL;
X }
X
X fclose(fp);
X return(0);
X}
X
X/*
X * If the user clears the screen with the ^A-C command, the input
X * has to be in sync. The way it gets notified, is that the vs_path
X * file disappears.
X */
X
Xint
Xclear_vs(max_row, max_col)
Xint max_row, max_col;
X{
X int i, j;
X
X for (i=0; i<max_row; i++) {
X vs[i][max_col] = NULL;
X for (j=0; j<max_col; j++)
X vs[i][j] = ' ';
X }
X /* home the "cursor" */
X row = 0;
X col = 0;
X return(0);
X}
X
X/*
X * Do a software scroll on the virtual screen. Does not alter the
X * 'col' variable.
X */
X
Xint
Xscroll_vs(max_row, max_col)
Xint max_row, max_col;
X{
X int i, j;
X char *strcpy();
X /* move 'em up 1 line */
X for (i=0; i<max_row-1; i++)
X strcpy((char *) vs[i], (char *) vs[i+1]);
X /* clear the bottom line */
X for (j=0; j<max_col; j++)
X vs[max_row-1][j] = ' ';
X
X row = max_row -1;
X return(0);
X}
SHAR_EOF
if test 6599 -ne "`wc -c < 'input.c'`"
then
echo shar: "error transmitting 'input.c'" '(should have been 6599 characters)'
fi
fi
echo shar: "extracting 'line_set.c'" '(2130 characters)'
if test -f 'line_set.c'
then
echo shar: "will not over-write existing file 'line_set.c'"
else
sed 's/^X//' << \SHAR_EOF > 'line_set.c'
X/*
X * Change the communication line settings to the new values.
X */
X
X#include <stdio.h>
X#include <termio.h>
X#include "dial_dir.h"
X#include "param.h"
X#include "status.h"
X
Xvoid
Xline_set()
X{
X struct termio tbuf;
X
X /*
X * The manual dial entry also serves to store the previous
X * line settings. How else would the manual dial entry
X * know what line setting to use?
X */
X if (dir->d_cur != 0) {
X dir->baud[0] = dir->baud[dir->d_cur];
X dir->parity[0] = dir->parity[dir->d_cur];
X dir->dbits[0] = dir->dbits[dir->d_cur];
X dir->sbits[0] = dir->sbits[dir->d_cur];
X }
X /* nothing to do! */
X if (status->fd == -1)
X return;
X /* get the current settings */
X ioctl(status->fd, TCGETA, &tbuf);
X /* set some beginning values */
X tbuf.c_cc[4] = 1;
X tbuf.c_cc[5] = 0;
X tbuf.c_oflag = 0;
X tbuf.c_iflag = 0;
X tbuf.c_cflag = (CREAD|HUPCL);
X tbuf.c_lflag = 0;
X
X /*
X * I don't think there's any need for output flow control... (I don't
X * know about you guys, but I can't type faster than the host can
X * receive!) Besides, the file transfers reset this anyway.
X */
X if (*param->flow == 'X')
X tbuf.c_iflag |= IXOFF;
X /* strip high bit ? */
X if (*param->strip == 'Y')
X tbuf.c_iflag |= ISTRIP;
X /* the baud rate */
X switch (dir->baud[dir->d_cur]) {
X case 300:
X tbuf.c_cflag |= B300;
X break;
X case 1200:
X tbuf.c_cflag |= B1200;
X break;
X case 2400:
X tbuf.c_cflag |= B2400;
X break;
X case 4800:
X tbuf.c_cflag |= B4800;
X break;
X case 9600:
X tbuf.c_cflag |= B9600;
X break;
X case 19200:
X /*
X * Be careful here... some systems use EXTA in lieu
X * of B19200.
X */
X tbuf.c_cflag |= B19200;
X break;
X }
X /* the parity */
X switch (dir->parity[dir->d_cur]) {
X case 'N':
X break;
X case 'O':
X tbuf.c_cflag |= (PARENB|PARODD);
X break;
X case 'E':
X tbuf.c_cflag |= PARENB;
X break;
X }
X /* the data bits */
X if (dir->dbits[dir->d_cur] == 8)
X tbuf.c_cflag |= CS8;
X else
X tbuf.c_cflag |= CS7;
X /* the stop bits */
X if (dir->sbits[dir->d_cur] == 2)
X tbuf.c_cflag |= CSTOPB;
X
X /* now set 'em! */
X ioctl(status->fd, TCSETA, &tbuf);
X ioctl(status->fd, TCFLSH, 2);
X return;
X}
SHAR_EOF
if test 2130 -ne "`wc -c < 'line_set.c'`"
then
echo shar: "error transmitting 'line_set.c'" '(should have been 2130 characters)'
fi
fi
echo shar: "extracting 'list_dir.c'" '(1479 characters)'
if test -f 'list_dir.c'
then
echo shar: "will not over-write existing file 'list_dir.c'"
else
sed 's/^X//' << \SHAR_EOF > 'list_dir.c'
X/*
X * Do a shell escape with an 'ls' command
X */
X
X#include <stdio.h>
X#include <curses.h>
X#include "misc.h"
X
Xvoid
Xlist_dir(fd)
Xint fd;
X{
X WINDOW *ls_win, *newwin();
X FILE *pfp, *native_popen();
X int lines, oops;
X char *ans, *cwd, *getcwd(), buf[200], *get_str();
X
X ls_win = newwin(6, 70, 8, 5);
X
X cwd = getcwd(buf, 200);
X
X mvwprintw(ls_win, 2, 4, "Current directory: %s", cwd);
X mvwaddstr(ls_win, 3, 4, "File spec (wildcards allowed): ");
X box(ls_win, '|', '-');
X
X mvwattrstr(ls_win, 0, 3, A_BOLD, " List Directory ");
X wmove(ls_win, 3, 35);
X wrefresh(ls_win);
X
X if ((ans = get_str(ls_win, 60, NULL, NULL)) == NULL) {
X if (fd == -1) {
X werase(ls_win);
X wrefresh(ls_win);
X }
X delwin(ls_win);
X return;
X }
X /* popen() an ls */
X sprintf(buf, "ls -aC %s", ans);
X pfp = native_popen(buf, "r");
X /* make a bigger window */
X werase(ls_win);
X wrefresh(ls_win);
X delwin(ls_win);
X ls_win = newwin(LINES-1, COLS, 0, 0);
X
X oops = 0;
X lines = 0;
X while (fgets(buf, BUFSIZ, pfp) != NULL) {
X waddstr(ls_win, buf);
X lines++;
X if (lines == LINES-2) {
X lines = 0;
X mvwaddstr(ls_win, LINES-2, 28, "Press any key for more");
X wrefresh(ls_win);
X if (wgetch(ls_win) == 27) {
X oops++;
X break;
X }
X werase(ls_win);
X wrefresh(ls_win);
X }
X }
X native_pclose(pfp);
X
X if (!oops) {
X mvwaddstr(ls_win, LINES-2, 25, "Press any key to continue");
X wrefresh(ls_win);
X wgetch(ls_win);
X }
X if (fd == -1) {
X werase(ls_win);
X wrefresh(ls_win);
X }
X delwin(ls_win);
X return;
X}
SHAR_EOF
if test 1479 -ne "`wc -c < 'list_dir.c'`"
then
echo shar: "error transmitting 'list_dir.c'" '(should have been 1479 characters)'
fi
fi
echo shar: "extracting 'ls_menu.c'" '(4820 characters)'
if test -f 'ls_menu.c'
then
echo shar: "will not over-write existing file 'ls_menu.c'"
else
sed 's/^X//' << \SHAR_EOF > 'ls_menu.c'
X/*
X * Routines for displaying current line settings and prompting for changes.
X */
X
X#include <stdio.h>
X#include <curses.h>
X#include "dial_dir.h"
X#include "misc.h"
X#include "param.h"
X
X/*
X * Display the current line settings and prompt for changes. A return
X * code of 1 means settings were changed.
X */
X
Xint
Xline_set_menu(fd)
Xint fd;
X{
X WINDOW *l_win, *newwin();
X int num, ret_code;
X void disp_settings();
X
X l_win = newwin(20, 47, 0, 16);
X
X mvwattrstr(l_win, 1, 16, A_BOLD, "Line Settings");
X waddstr(l_win, "\n----------------------------------------------");
X mvwaddstr(l_win, 6, 5, "1) 300,E,7,1 7) 300,N,8,1");
X mvwaddstr(l_win, 7, 5, "2) 1200,E,7,1 8) 1200,N,8,1");
X mvwaddstr(l_win, 8, 5, "3) 2400,E,7,1 9) 2400,N,8,1");
X mvwaddstr(l_win, 9, 5, "4) 4800,E,7,1 10) 4800,N,8,1");
X mvwaddstr(l_win, 10, 5, "5) 9600,E,7,1 11) 9600,N,8,1");
X mvwaddstr(l_win, 11, 5, "6) 19200,E,7,1 12) 19200,N,8,1");
X mvwaddstr(l_win, 13, 4, "Parity Data Bits Stop Bits");
X mvwaddstr(l_win, 14, 4, "13) Odd 14) 7 bits 16) 1 bit");
X mvwaddstr(l_win, 15, 18, "15) 8 bits 17) 2 bits");
X mvwaddstr(l_win, 17, 4, "18) Save Changes");
X mvwattrstr(l_win, 17, 28, A_BOLD, "YOUR CHOICE:");
X wmove(l_win, 17, 41);
X box(l_win, '|', '-');
X
X mvwaddstr(l_win, 19, 14, " Press ESC to return ");
X /* display current settings */
X disp_settings(l_win);
X wmove(l_win, 17, 41);
X wrefresh(l_win);
X /* get the options */
X ret_code = 0;
X while ((num = get_num(l_win, 2)) != -1) {
X switch(num) {
X case 1:
X dir->baud[dir->d_cur] = 300;
X dir->parity[dir->d_cur] = 'E';
X dir->dbits[dir->d_cur] = 7;
X dir->sbits[dir->d_cur] = 1;
X break;
X case 2:
X dir->baud[dir->d_cur] = 1200;
X dir->parity[dir->d_cur] = 'E';
X dir->dbits[dir->d_cur] = 7;
X dir->sbits[dir->d_cur] = 1;
X break;
X case 3:
X dir->baud[dir->d_cur] = 2400;
X dir->parity[dir->d_cur] = 'E';
X dir->dbits[dir->d_cur] = 7;
X dir->sbits[dir->d_cur] = 1;
X break;
X case 4:
X dir->baud[dir->d_cur] = 4800;
X dir->parity[dir->d_cur] = 'E';
X dir->dbits[dir->d_cur] = 7;
X dir->sbits[dir->d_cur] = 1;
X break;
X case 5:
X dir->baud[dir->d_cur] = 9600;
X dir->parity[dir->d_cur] = 'E';
X dir->dbits[dir->d_cur] = 7;
X dir->sbits[dir->d_cur] = 1;
X break;
X case 6:
X dir->baud[dir->d_cur] = 19200;
X dir->parity[dir->d_cur] = 'E';
X dir->dbits[dir->d_cur] = 7;
X dir->sbits[dir->d_cur] = 1;
X break;
X case 7:
X dir->baud[dir->d_cur] = 300;
X dir->parity[dir->d_cur] = 'N';
X dir->dbits[dir->d_cur] = 8;
X dir->sbits[dir->d_cur] = 1;
X break;
X case 8:
X dir->baud[dir->d_cur] = 1200;
X dir->parity[dir->d_cur] = 'N';
X dir->dbits[dir->d_cur] = 8;
X dir->sbits[dir->d_cur] = 1;
X break;
X case 9:
X dir->baud[dir->d_cur] = 2400;
X dir->parity[dir->d_cur] = 'N';
X dir->dbits[dir->d_cur] = 8;
X dir->sbits[dir->d_cur] = 1;
X break;
X case 10:
X dir->baud[dir->d_cur] = 4800;
X dir->parity[dir->d_cur] = 'N';
X dir->dbits[dir->d_cur] = 8;
X dir->sbits[dir->d_cur] = 1;
X break;
X case 11:
X dir->baud[dir->d_cur] = 9600;
X dir->parity[dir->d_cur] = 'N';
X dir->dbits[dir->d_cur] = 8;
X dir->sbits[dir->d_cur] = 1;
X break;
X case 12:
X dir->baud[dir->d_cur] = 19200;
X dir->parity[dir->d_cur] = 'N';
X dir->dbits[dir->d_cur] = 8;
X dir->sbits[dir->d_cur] = 1;
X break;
X case 13:
X dir->parity[dir->d_cur] = 'O';
X break;
X case 14:
X dir->dbits[dir->d_cur] = 7;
X break;
X case 15:
X dir->dbits[dir->d_cur] = 8;
X break;
X case 16:
X dir->sbits[dir->d_cur] = 1;
X break;
X case 17:
X dir->sbits[dir->d_cur] = 2;
X break;
X case 18:
X /* copy the current settings */
X param->d_baud = dir->baud[dir->d_cur];
X param->d_parity = dir->parity[dir->d_cur];
X param->d_dbits = dir->dbits[dir->d_cur];
X param->d_sbits = dir->sbits[dir->d_cur];
X /*
X * We've changed the values in memory even
X * if the update fails.
X */
X if (update_param()) {
X touchwin(l_win);
X wrefresh(l_win);
X }
X break;
X default:
X beep();
X }
X ret_code++;
X disp_settings(l_win);
X mvwaddstr(l_win, 17, 41, " ");
X wmove(l_win, 17, 41);
X wrefresh(l_win);
X }
X if (fd == -1) {
X werase(l_win);
X wrefresh(l_win);
X }
X delwin(l_win);
X return(ret_code);
X}
X
X/*
X * Display the current settings. Formats the entire string at one
X * time, in case you've got a magic cookie terminal.
X */
X
Xvoid
Xdisp_settings(win)
XWINDOW *win;
X{
X char buf[40];
X extern int xmc;
X
X sprintf(buf, "Current Settings: %5d,%c,%d,%d", dir->baud[dir->d_cur],
X dir->parity[dir->d_cur], dir->dbits[dir->d_cur],
X dir->sbits[dir->d_cur]);
X
X if (xmc > 0) {
X touchwin(win);
X clear_line(win, 4, 8, 1);
X wrefresh(win);
X }
X mvwattrstr(win, 4, 8, A_BOLD, buf);
X return;
X}
SHAR_EOF
if test 4820 -ne "`wc -c < 'ls_menu.c'`"
then
echo shar: "error transmitting 'ls_menu.c'" '(should have been 4820 characters)'
fi
fi
echo shar: "extracting 'm_lib.c'" '(9489 characters)'
if test -f 'm_lib.c'
then
echo shar: "will not over-write existing file 'm_lib.c'"
else
sed 's/^X//' << \SHAR_EOF > 'm_lib.c'
X/*
X * Routines to manipulate the pcomm.modem file
X */
X
X#include <stdio.h>
X#include "modem.h"
X#include "status.h"
X
X/*
X * Read the modem database file. Returns a pointer to a static area
X * containing the MODEM structure. All modem entries and all tty entries
X * are created reguardless of the number of physical entries in the file.
X */
X
Xstruct MODEM *
Xread_modem()
X{
X FILE *fp;
X int i, tty, mod, line, oops, m_line, start, stop;
X char *strdup(), buf[200], message[80], token[40], *str_tok(), *str;
X char *temp_token, *t_sep, *m_sep, *m_letter;
X static struct MODEM m;
X void error_win();
X extern char *null_ptr;
X
X if (!(fp = fopen(status->m_path, "r"))) {
X sprintf(buf, "'%s' for read", status->m_path);
X error_win(1, "Can't open modem file", buf);
X }
X
X t_sep = ";;\n";
X m_sep = ";;;;\n;;;;;\n;;;\n";
X m_letter = "abc";
X oops = 0;
X tty = 0;
X mod = 0;
X line = 0;
X m_line = 0;
X while (fgets(buf, 200, fp) != NULL) {
X line++;
X if (tty >= NUM_TTY || mod >= NUM_MODEM)
X break;
X /* get the token */
X if (!(temp_token = str_tok(buf, '='))) {
X sprintf(message, "is missing a token at line %d", line);
X oops++;
X break;
X }
X if (*temp_token != 'T' && *temp_token != 'M') {
X sprintf(message, "is corrupted at line %d", line);
X oops++;
X break;
X }
X /* the tty database */
X if (*temp_token == 'T') {
X /*
X * This is similar to the "real" strtok() command
X * but this one returns a null pointer on a missing
X * attribute. Note the use of the field separator
X * array.
X */
X for (i=0; i<3; i++) {
X if (!(str = str_tok((char *) NULL, t_sep[i]))) {
X sprintf(message, "is missing a parameter at line %d", line);
X oops++;
X break;
X }
X switch(i) {
X case 0:
X m.tty[tty] = strdup(str);
X break;
X case 1:
X m.tname[tty] = strdup(str);
X break;
X case 2:
X m.mbaud[tty] = atoi(str);
X break;
X }
X }
X if (oops)
X break;
X /* sanity checking */
X sprintf(token, "TTY_%d", tty+1);
X if (strcmp(token, temp_token)) {
X sprintf(message, "is corrupted at line %d", line);
X oops++;
X break;
X }
X tty++;
X continue;
X }
X /* the modem database */
X else {
X sprintf(token, "MODEM_%d%c", mod+1, m_letter[m_line]);
X if (strcmp(token, temp_token)) {
X sprintf(message, "is corrupted at line %d", line);
X oops++;
X break;
X }
X /*
X * There are three lines to the modem database. They
X * distinguished by the letters a, b, and, c appended
X * to the entry number.
X */
X switch(m_line) {
X case 0:
X start = 0;
X stop = 5;
X break;
X case 1:
X start = 5;
X stop = 11;
X break;
X case 2:
X start = 11;
X stop = 15;
X break;
X }
X for (i=start; i<stop; i++) {
X if (!(str = str_tok((char *) NULL, m_sep[i]))) {
X sprintf(message, "is missing a parameter at line %d", line);
X oops++;
X break;
X }
X switch(i) {
X case 0:
X m.mname[mod] = strdup(str);
X break;
X case 1:
X m.init[mod] = strdup(str);
X break;
X case 2:
X m.dial[mod] = strdup(str);
X break;
X case 3:
X m.suffix[mod] = strdup(str);
X break;
X case 4:
X m.hangup[mod] = strdup(str);
X break;
X case 5:
X m.con_3[mod] = strdup(str);
X break;
X case 6:
X m.con_12[mod] = strdup(str);
X break;
X case 7:
X m.con_24[mod] = strdup(str);
X break;
X case 8:
X m.con_48[mod] = strdup(str);
X break;
X case 9:
X m.con_96[mod] = strdup(str);
X break;
X case 10:
X m.con_192[mod] = strdup(str);
X break;
X case 11:
X m.no_con1[mod] = strdup(str);
X break;
X case 12:
X m.no_con2[mod] = strdup(str);
X break;
X case 13:
X m.no_con3[mod] = strdup(str);
X break;
X case 14:
X m.no_con4[mod] = strdup(str);
X break;
X }
X }
X if (oops)
X break;
X m_line++;
X if (m_line >= 3) {
X m_line = 0;
X mod++;
X }
X }
X }
X fclose(fp);
X
X if (oops) {
X sprintf(buf, "Modem file '%s'", status->m_path);
X error_win(1, buf, message);
X }
X m.t_entries = tty;
X m.m_entries = mod;
X m.t_cur = -1;
X m.m_cur = -1;
X /* fill in the rest */
X for (; tty<NUM_TTY; tty++) {
X m.tty[tty] = null_ptr;
X m.tname[tty] = null_ptr;
X m.mbaud[tty] = 0;
X }
X for (; mod<NUM_MODEM; mod++) {
X m.mname[mod] = null_ptr;
X m.init[mod] = null_ptr;
X m.dial[mod] = null_ptr;
X m.suffix[mod] = null_ptr;
X m.hangup[mod] = null_ptr;
X
X m.con_3[mod] = null_ptr;
X m.con_12[mod] = null_ptr;
X m.con_24[mod] = null_ptr;
X m.con_48[mod] = null_ptr;
X m.con_96[mod] = null_ptr;
X m.con_192[mod] = null_ptr;
X
X m.no_con1[mod] = null_ptr;
X m.no_con2[mod] = null_ptr;
X m.no_con3[mod] = null_ptr;
X m.no_con4[mod] = null_ptr;
X }
X return(&m);
X}
X
X/*
X * Update the modem database. Other routines actually do the changes
X * or deletions in memory. A return code of 1 means non-fatal error.
X */
X
Xint
Xupdate_modem()
X{
X FILE *fp;
X char buf[80];
X int i;
X void error_win();
X
X /* open for write */
X if (!(fp = fopen(status->m_path, "w"))) {
X sprintf(buf, "'%s'", status->m_path);
X error_win(0, "No write permission on modem file", buf);
X return(1);
X }
X /* put back the tty entries */
X for (i=0; i<modem->t_entries; i++)
X fprintf(fp, "TTY_%d=%s;%s;%d\n", i+1, modem->tty[i],
X modem->tname[i], modem->mbaud[i]);
X
X /* put back the modem entries */
X for (i=0; i<modem->m_entries; i++) {
X fprintf(fp, "MODEM_%da=%s;%s;%s;%s;%s\n", i+1, modem->mname[i],
X modem->init[i], modem->dial[i], modem->suffix[i],
X modem->hangup[i]);
X
X fprintf(fp, "MODEM_%db=%s;%s;%s;%s;%s;%s\n", i+1,
X modem->con_3[i], modem->con_12[i], modem->con_24[i],
X modem->con_48[i], modem->con_96[i], modem->con_192[i]);
X
X fprintf(fp, "MODEM_%dc=%s;%s;%s;%s\n", i+1, modem->no_con1[i],
X modem->no_con2[i], modem->no_con3[i], modem->no_con4[i]);
X }
X
X fclose(fp);
X return(0);
X}
X
X/*
X * See if the new modem is already in the database. If it's not,
X * then create a slot for it and update the modem->m_cur variable.
X */
X
Xvoid
Xcreate_modem(str)
Xchar *str;
X{
X int i;
X char *strdup(), buf[80];
X void error_win(), free_ptr();
X /* modem entry already exists? */
X for (i=0; i<modem->m_entries; i++) {
X if (!strcmp(str, modem->mname[i]))
X return;
X }
X /* empty slot available? */
X if (modem->m_entries == NUM_MODEM) {
X sprintf(buf, "'%s'", status->m_path);
X error_win(0, "No empty modem slots in", buf);
X return;
X }
X /* create a new entry */
X free_ptr(modem->mname[modem->m_entries]);
X modem->mname[modem->m_entries] = strdup(str);
X
X /* update number of entries */
X modem->m_entries++;
X return;
X}
X
X/*
X * See if the modem names in the list still need to be in the database.
X * If you find a "lost" entry, delete it and collapse the list.
X */
X
Xvoid
Xdelete_modem()
X{
X int i, j, match;
X char *strdup();
X void free_ptr();
X extern char *null_ptr;
X
X for (i=0; i<modem->m_entries; i++) {
X match = 0;
X for (j=0; j<modem->t_entries; j++) {
X if (!strcmp(modem->mname[i], modem->tname[j])) {
X match = 1;
X break;
X }
X }
X /* found a "lost" modem name */
X if (!match) {
X for (j=i; j<modem->m_entries-1; j++) {
X free_ptr(modem->mname[j]);
X free_ptr(modem->init[j]);
X free_ptr(modem->dial[j]);
X free_ptr(modem->suffix[j]);
X free_ptr(modem->hangup[j]);
X
X free_ptr(modem->con_3[j]);
X free_ptr(modem->con_12[j]);
X free_ptr(modem->con_24[j]);
X free_ptr(modem->con_48[j]);
X free_ptr(modem->con_96[j]);
X free_ptr(modem->con_192[j]);
X
X free_ptr(modem->no_con1[j]);
X free_ptr(modem->no_con2[j]);
X free_ptr(modem->no_con3[j]);
X free_ptr(modem->no_con4[j]);
X
X /* copy the info */
X modem->mname[j] = strdup(modem->mname[j+1]);
X modem->init[j] = strdup(modem->init[j+1]);
X modem->dial[j] = strdup(modem->dial[j+1]);
X modem->suffix[j] = strdup(modem->suffix[j+1]);
X modem->hangup[j] = strdup(modem->hangup[j+1]);
X
X modem->con_3[j] = strdup(modem->con_3[j+1]);
X modem->con_12[j] = strdup(modem->con_12[j+1]);
X modem->con_24[j] = strdup(modem->con_24[j+1]);
X modem->con_48[j] = strdup(modem->con_48[j+1]);
X modem->con_96[j] = strdup(modem->con_96[j+1]);
X modem->con_192[j] = strdup(modem->con_192[j+1]);
X
X modem->no_con1[j] = strdup(modem->no_con1[j+1]);
X modem->no_con2[j] = strdup(modem->no_con2[j+1]);
X modem->no_con3[j] = strdup(modem->no_con3[j+1]);
X modem->no_con4[j] = strdup(modem->no_con4[j+1]);
X }
X j = modem->m_entries -1;
X
X free_ptr(modem->mname[j]);
X free_ptr(modem->init[j]);
X free_ptr(modem->dial[j]);
X free_ptr(modem->suffix[j]);
X free_ptr(modem->hangup[j]);
X
X free_ptr(modem->con_3[j]);
X free_ptr(modem->con_12[j]);
X free_ptr(modem->con_24[j]);
X free_ptr(modem->con_48[j]);
X free_ptr(modem->con_96[j]);
X free_ptr(modem->con_192[j]);
X
X free_ptr(modem->no_con1[j]);
X free_ptr(modem->no_con2[j]);
X free_ptr(modem->no_con3[j]);
X free_ptr(modem->no_con4[j]);
X
X /* create an empty entry */
X modem->mname[j] = null_ptr;
X modem->init[j] = null_ptr;
X modem->dial[j] = null_ptr;
X modem->suffix[j] = null_ptr;
X modem->hangup[j] = null_ptr;
X
X modem->con_3[j] = null_ptr;
X modem->con_12[j] = null_ptr;
X modem->con_24[j] = null_ptr;
X modem->con_48[j] = null_ptr;
X modem->con_96[j] = null_ptr;
X modem->con_192[j] = null_ptr;
X
X modem->no_con1[j] = null_ptr;
X modem->no_con2[j] = null_ptr;
X modem->no_con3[j] = null_ptr;
X modem->no_con4[j] = null_ptr;
X
X /* update the counts */
X modem->m_entries--;
X if (modem->m_cur >= modem->m_entries)
X modem->m_cur = -1;
X return;
X }
X }
X return;
X}
SHAR_EOF
if test 9489 -ne "`wc -c < 'm_lib.c'`"
then
echo shar: "error transmitting 'm_lib.c'" '(should have been 9489 characters)'
fi
fi
echo shar: "extracting 'main.c'" '(4860 characters)'
if test -f 'main.c'
then
echo shar: "will not over-write existing file 'main.c'"
else
sed 's/^X//' << \SHAR_EOF > 'main.c'
X/*
X * Pcomm is a public domain telecommunication program for Unix
X * designed to operate similar to the popular MSDOS program, ProComm.
X * ProComm (TM) is copyrighted by Datastorm Technologies, Inc.
X *
X * Emmet P. Gray US Army, HQ III Corps & Fort Hood
X * ...!ihnp4!uiucuxc!fthood!egray Attn: AFZF-DE-ENV
X * Directorate of Engineering & Housing
X * Environmental Management Office
X * Fort Hood, TX 76544-5057
X * Beta release 7 Feb 88
X * Release 1.0 12 Mar 88
X */
X
X#include <stdio.h>
X#include <signal.h>
X#include <curses.h>
X#ifndef OLDCURSES
X#include <term.h>
X#endif /* OLDCURSES */
X#include <sys/types.h>
X#include <sys/stat.h>
X#define MAIN
X#include "dial_dir.h"
X#include "modem.h"
X#include "param.h"
X#include "status.h"
X
X#ifdef OLDCURSES
Xchar bp[1024];
X#define cbreak crmode
X#endif /* OLDCURSES */
X
Xstruct PARAM *param;
Xstruct DIAL_DIR *dir;
Xstruct STATUS *status;
Xstruct MODEM *modem;
Xint xmc;
Xchar *null_ptr;
X
Xmain(argc, argv)
Xint argc;
Xchar *argv[];
X{
X int c, ret_code, i, code, quit();
X char *mytty, *ttyname(), *term, *getenv(), *index, *strdup();
X char *extra_dir, buf[80], message[80];
X struct PARAM *read_param();
X struct DIAL_DIR *read_dir();
X struct STATUS *init();
X struct MODEM *read_modem();
X struct stat stbuf;
X void exit(), error_win(), input_on(), free_ptr();
X extern char *optarg;
X#ifdef OLDCURSES
X char *tgetstr(), ocbuf[20];
X char *ocbufptr = ocbuf;
X#endif /* OLDCURSES */
X
X signal(SIGINT, SIG_IGN);
X signal(SIGQUIT, SIG_IGN);
X signal(SIGTERM, quit);
X signal(SIGHUP, quit);
X
X null_ptr = "";
X index = NULL;
X extra_dir = NULL;
X /* the command line */
X while ((c = getopt(argc, argv, "d:f:")) != EOF) {
X switch (c) {
X case 'd': /* the extra directory to search */
X extra_dir = strdup(optarg);
X break;
X case 'f': /* the index into the dialing dir */
X index = strdup(optarg);
X break;
X case '?': /* default */
X fprintf(stderr, "Usage: pcomm [-d directory] [-f index]\n");
X exit(1);
X break;
X }
X }
X /* get terminal type */
X term = getenv("TERM");
X if (term == NULL || *term == NULL) {
X fprintf(stderr, "Windows not supported (TERM not defined)\n");
X exit(1);
X }
X /* see if terminfo entry exists */
X#ifdef OLDCURSES
X ret_code = tgetent(bp, term);
X#else /* OLDCURSES */
X setupterm(term, 1, &ret_code);
X#endif /* OLDCURSES */
X if (ret_code != 1) {
X fprintf(stderr, "Windows not supported (no terminfo data for '%s')\n", term);
X exit(1);
X }
X /* minimum screen size */
X#ifdef OLDCURSES
X if (tgetnum("co") < 80 || tgetnum("li") < 24) {
X#else /* OLDCURSES */
X if (columns < 80 || lines < 24) {
X#endif /* OLDCURSES */
X fprintf(stderr, "Windows not supported (minimum 80x24 screen required)\n");
X exit(1);
X }
X /* must have cursor movement */
X#ifdef OLDCURSES
X if (tgetstr("cm", &ocbufptr) == NULL) {
X#else /* OLDCURSES */
X if (cursor_address == NULL) {
X#endif /* OLDCURSES */
X fprintf(stderr, "Windows not supported (terminal too dumb)\n");
X exit(1);
X }
X /* load magic cookie variable */
X#ifdef OLDCURSES
X xmc = tgetnum("sg");
X#else /* OLDCURSES */
X xmc = magic_cookie_glitch;
X#endif /* OLDCURSES */
X /* ok... now lets go! */
X initscr();
X nonl();
X cbreak();
X noecho();
X
X param = (struct PARAM *) NULL;
X modem = (struct MODEM *) NULL;
X dir = (struct DIAL_DIR *) NULL;
X /* show the herald, return status */
X status = init(extra_dir, index);
X /* get 'msgs' status */
X mytty = ttyname(0);
X stat(mytty, &stbuf);
X chmod(mytty, 0600);
X status->msg = stbuf.st_mode & 0777;
X /* read the support files */
X param = read_param();
X dir = read_dir();
X modem = read_modem();
X /* short-cut to dialing window ? */
X code = 0;
X if (index != NULL) {
X for (i=1; i<dir->d_entries+1; i++) {
X if (!strcmp(dir->index[i], index)) {
X dir->q_num[0] = i;
X dir->d_cur = i;
X break;
X }
X }
X /* if match is found */
X if (dir->q_num[0] != -1)
X code = dial_win();
X else {
X sprintf(buf, "Can't find index '%s' in dialing directory file", index);
X sprintf(message, "'%s'", status->d_path);
X error_win(0, buf, message);
X }
X free_ptr(index);
X }
X /* start terminal dialogue */
X terminal(code);
X exit(0);
X}
X
X/*
X * Something dreadful happened... Cleanup the mess we made with the
X * tty driver and release the phone line.
X */
X
Xint
Xquit()
X{
X void cleanup();
X
X cleanup(1);
X /* never returns... */
X return(0);
X}
X
X/*
X * Check write permission with the real UID and GID. Returns a 0 on
X * permission denied, 1 on OK, and 2 on OK-but the file already exists.
X */
X
Xint
Xcan_write(file)
Xchar *file;
X{
X char *p, path[200], *strcpy(), *strrchr();
X
X p = strcpy(path, file);
X /* dissect the path component */
X if (p = strrchr(path, '/'))
X *(p++) = NULL;
X else
X strcpy(path, ".");
X /* if it already exists */
X if (!access(file, 0)) {
X if (!access(file, 2))
X return(2);
X return(0);
X }
X /* if path is writable */
X if (!access(path, 2))
X return(1);
X return(0);
X}
SHAR_EOF
if test 4860 -ne "`wc -c < 'main.c'`"
then
echo shar: "error transmitting 'main.c'" '(should have been 4860 characters)'
fi
fi
echo shar: "extracting 'n_shell.c'" '(1369 characters)'
if test -f 'n_shell.c'
then
echo shar: "will not over-write existing file 'n_shell.c'"
else
sed 's/^X//' << \SHAR_EOF > 'n_shell.c'
X/*
X * Spawn a 'native' shell. 'Native' means the shell found in the SHELL
X * environmental variable.
X */
X
X#include <stdio.h>
X#include <signal.h>
X#include <curses.h>
X
Xvoid
Xnative_shell()
X{
X WINDOW *sh_win, *newwin();
X int (*istat)(), (*qstat)(), status, pid, w;
X char *shell, *shellpath, *getenv(), *strrchr();
X unsigned int sleep();
X void _exit();
X /* a full window */
X sh_win = newwin(LINES, COLS, 0, 0);
X
X clear_absolute(sh_win);
X waddstr(sh_win, "Pcomm <=> Unix gateway, use ^D or 'exit' to return\n");
X wrefresh(sh_win);
X /* out of curses mode */
X resetterm();
X
X shellpath = getenv("SHELL");
X if (shellpath == NULL || *shellpath == NULL)
X shellpath = "/bin/sh";
X
X shell = strrchr(shellpath, '/') + 1;
X
X if (!(pid = fork())) {
X#ifdef SGID
X setgid(getgid());
X#endif /* SGID */
X execl(shellpath, shell, "-i", 0);
X _exit(1);
X }
X istat = signal(SIGINT, SIG_IGN);
X qstat = signal(SIGQUIT, SIG_IGN);
X
X while ((w = wait(&status)) != pid && w != -1)
X ;
X
X signal(SIGINT, istat);
X signal(SIGQUIT, qstat);
X /* back to curses mode */
X fixterm();
X sleep(1);
X
X clear_absolute(stdscr);
X delwin(sh_win);
X return;
X}
X
X/*
X * Clear the screen absolutely! It's incrediblely hard to get curses() to
X * clear the screen when it thinks its already clear.
X */
X
Xint
Xclear_absolute(win)
XWINDOW *win;
X{
X clearok(curscr, 1);
X wrefresh(win);
X clearok(curscr, 0);
X return(0);
X}
SHAR_EOF
if test 1369 -ne "`wc -c < 'n_shell.c'`"
then
echo shar: "error transmitting 'n_shell.c'" '(should have been 1369 characters)'
fi
fi
echo shar: "extracting 'p_lib.c'" '(5786 characters)'
if test -f 'p_lib.c'
then
echo shar: "will not over-write existing file 'p_lib.c'"
else
sed 's/^X//' << \SHAR_EOF > 'p_lib.c'
X/*
X * Routines to manipulate the pcomm.param file.
X */
X
X#include <stdio.h>
X#include "param.h"
X#include "status.h"
X
X/*
X * Read the parameter structure from the pcomm.param file. Returns a
X * pointer to the PARAM structure. All errors are fatal.
X */
X
Xstruct PARAM *
Xread_param()
X{
X FILE *fp;
X int i, oops;
X char buf[80], *temp_token, *str, *strdup();
X char message[80], *str_tok();
X static char *token[NUM_PARAM] = {"D_BAUD", "D_PARITY", "D_DBITS",
X "D_SBITS", "HOT", "ASCII_HOT", "D_DUPLEX", "FLOW", "CR_IN", "CR_OUT",
X "LOGFILE", "DUMPFILE", "STRIP", "PAUSE_CHAR", "CR_CHAR", "CTRL_CHAR",
X "ESC_CHAR", "ABORT", "CDELAY", "PAUSE", "LECHO", "EXPAND", "CR_DELAY",
X "PACE", "CR_UP", "LF_UP", "TIMER", "CR_DN", "LF_DN", "LD_PLUS",
X "LD_MINUS", "LD_AT", "LD_POUND"};
X static struct PARAM p;
X void error_win();
X /* read permission already checked */
X fp = fopen(status->p_path, "r");
X
X oops = 0;
X for (i=0; i<NUM_PARAM; i++) {
X if (fgets(buf, 80, fp) == NULL) {
X sprintf(message, "is truncated at line %d", i+1);
X oops++;
X break;
X }
X /* parse the input line */
X if (!(temp_token = str_tok(buf, '='))) {
X sprintf(message, "is missing a token at line %d", i+1);
X oops++;
X break;
X }
X if (!(str = str_tok((char *) NULL, '\n'))) {
X sprintf(message, "is missing a parameter at line %d", i+1);
X oops++;
X break;
X }
X /* sanity checking */
X if (strcmp(temp_token, token[i])) {
X sprintf(message, "is corrupted at line %d", i+1);
X oops++;
X break;
X }
X
X switch(i) {
X /* used in line_set_menu() */
X case LINE_SET:
X p.d_baud = atoi(str);
X break;
X case LINE_SET+1:
X p.d_parity = *str;
X break;
X case LINE_SET+2:
X p.d_dbits = atoi(str);
X break;
X case LINE_SET+3:
X p.d_sbits = atoi(str);
X break;
X
X /* used in term_setup() */
X case TERM_SETUP:
X p.hot = atoi(str);
X break;
X case TERM_SETUP+1:
X p.ascii_hot = strdup(str);
X break;
X case TERM_SETUP+2:
X p.d_duplex = strdup(str);
X break;
X case TERM_SETUP+3:
X p.flow = strdup(str);
X break;
X case TERM_SETUP+4:
X p.cr_in = strdup(str);
X break;
X case TERM_SETUP+5:
X p.cr_out = strdup(str);
X break;
X
X /* used in gen_setup() */
X case GEN_SETUP:
X p.logfile = strdup(str);
X break;
X case GEN_SETUP+1:
X p.dumpfile = strdup(str);
X break;
X case GEN_SETUP+2:
X p.strip = strdup(str);
X break;
X case GEN_SETUP+3:
X p.pause_char = *str;
X break;
X case GEN_SETUP+4:
X p.cr_char = *str;
X break;
X case GEN_SETUP+5:
X p.ctrl_char = *str;
X break;
X case GEN_SETUP+6:
X p.esc_char = *str;
X break;
X case GEN_SETUP+7:
X p.abort = strdup(str);
X break;
X
X /* used in gen_setup() delay_times() */
X case DELAY_TIMES:
X p.cdelay = atoi(str);
X break;
X case DELAY_TIMES+1:
X p.pause = atoi(str);
X break;
X
X /* used in ascii_xfer_setup() */
X case ASCII_SETUP:
X p.lecho = strdup(str);
X break;
X case ASCII_SETUP+1:
X p.expand = strdup(str);
X break;
X case ASCII_SETUP+2:
X p.cr_delay = atoi(str);
X break;
X case ASCII_SETUP+3:
X p.pace = strdup(str);
X break;
X case ASCII_SETUP+4:
X p.cr_up = strdup(str);
X break;
X case ASCII_SETUP+5:
X p.lf_up = strdup(str);
X break;
X case ASCII_SETUP+6:
X p.timer = atoi(str);
X break;
X case ASCII_SETUP+7:
X p.cr_dn = strdup(str);
X break;
X case ASCII_SETUP+8:
X p.lf_dn = strdup(str);
X break;
X
X /* used in d_revise() */
X case LD_CODES:
X p.ld_plus = strdup(str);
X break;
X case LD_CODES+1:
X p.ld_minus = strdup(str);
X break;
X case LD_CODES+2:
X p.ld_at = strdup(str);
X break;
X case LD_CODES+3:
X p.ld_pound = strdup(str);
X break;
X }
X }
X fclose(fp);
X if (oops) {
X sprintf(buf, "Parameter file '%s'", status->p_path);
X error_win(1, buf, message);
X }
X return(&p);
X}
X
X/*
X * Write the updated param structure to disk. The values in memory should
X * have already been "purified". Later, we'll update only the entries that
X * have been explicitly asked for. A return code of 1 means non-fatal error.
X */
X
Xint
Xupdate_param()
X{
X FILE *fp;
X char buf[80];
X void error_win();
X /* open for write */
X if (!(fp = fopen(status->p_path, "w"))) {
X sprintf(buf, "'%s'", status->p_path);
X error_win(0, "No write permission on parameter file", buf);
X return(1);
X }
X
X fprintf(fp, "D_BAUD=%d\n", param->d_baud);
X fprintf(fp, "D_PARITY=%c\n", param->d_parity);
X fprintf(fp, "D_DBITS=%d\n", param->d_dbits);
X fprintf(fp, "D_SBITS=%d\n", param->d_sbits);
X fprintf(fp, "HOT=%d\n", param->hot);
X fprintf(fp, "ASCII_HOT=%s\n", param->ascii_hot);
X fprintf(fp, "D_DUPLEX=%s\n", param->d_duplex);
X fprintf(fp, "FLOW=%s\n", param->flow);
X fprintf(fp, "CR_IN=%s\n", param->cr_in);
X fprintf(fp, "CR_OUT=%s\n", param->cr_out);
X fprintf(fp, "LOGFILE=%s\n", param->logfile);
X fprintf(fp, "DUMPFILE=%s\n", param->dumpfile);
X fprintf(fp, "STRIP=%s\n", param->strip);
X fprintf(fp, "PAUSE_CHAR=%c\n", param->pause_char);
X fprintf(fp, "CR_CHAR=%c\n", param->cr_char);
X fprintf(fp, "CTRL_CHAR=%c\n", param->ctrl_char);
X fprintf(fp, "ESC_CHAR=%c\n", param->esc_char);
X fprintf(fp, "ABORT=%s\n", param->abort);
X fprintf(fp, "CDELAY=%d\n", param->cdelay);
X fprintf(fp, "PAUSE=%d\n", param->pause);
X fprintf(fp, "LECHO=%s\n", param->lecho);
X fprintf(fp, "EXPAND=%s\n", param->expand);
X fprintf(fp, "CR_DELAY=%d\n", param->cr_delay);
X fprintf(fp, "PACE=%s\n", param->pace);
X fprintf(fp, "CR_UP=%s\n", param->cr_up);
X fprintf(fp, "LF_UP=%s\n", param->lf_up);
X fprintf(fp, "TIMER=%d\n", param->timer);
X fprintf(fp, "CR_DN=%s\n", param->cr_dn);
X fprintf(fp, "LF_DN=%s\n", param->lf_dn);
X fprintf(fp, "LD_PLUS=%s\n", param->ld_plus);
X fprintf(fp, "LD_MINUS=%s\n", param->ld_minus);
X fprintf(fp, "LD_AT=%s\n", param->ld_at);
X fprintf(fp, "LD_POUND=%s\n", param->ld_pound);
X
X fclose(fp);
X return(0);
X}
SHAR_EOF
if test 5786 -ne "`wc -c < 'p_lib.c'`"
then
echo shar: "error transmitting 'p_lib.c'" '(should have been 5786 characters)'
fi
fi
echo shar: "extracting 'pexit.c'" '(2142 characters)'
if test -f 'pexit.c'
then
echo shar: "will not over-write existing file 'pexit.c'"
else
sed 's/^X//' << \SHAR_EOF > 'pexit.c'
X/*
X * Exit pcomm. A user requested abort. There are a lot of things to do
X * before we exit!
X */
X
X#include <stdio.h>
X#include <curses.h>
X#include "dial_dir.h"
X#include "misc.h"
X#include "param.h"
X#include "status.h"
X
Xvoid
Xpexit(fd)
Xint fd;
X{
X WINDOW *ex_win, *newwin();
X void cleanup(), status_line();
X
X ex_win = newwin(5, 33, 3, 7);
X
X box(ex_win, '|', '-');
X mvwattrstr(ex_win, 0, 3, A_BOLD, " Exit ");
X if (yes_prompt(ex_win, 2, 4, A_BLINK, "Exit to Unix")) {
X status_line(" exiting");
X cleanup(0);
X }
X if (fd == -1) {
X werase(ex_win);
X wrefresh(ex_win);
X }
X delwin(ex_win);
X return;
X}
X
X/*
X * Do the cleanup detail before we exit.
X */
X
Xvoid
Xcleanup(val)
Xint val;
X{
X void release_port(), input_off(), exit(), status_line();
X char *ttyname();
X /* kill the input routine */
X input_off();
X /* zap the virtual screen file */
X unlink(status->vs_path);
X /* release the port */
X release_port(0);
X /* erase the window we made */
X touchwin(stdscr);
X clear();
X refresh();
X endwin();
X /* return the tty chmod */
X chmod(ttyname(0), status->msg);
X exit(val);
X}
X
X/*
X * Open a window to display an error message. Handles both fatal and
X * non-fatal errors
X */
X
Xvoid
Xerror_win(code, line_one, line_two)
Xint code;
Xchar *line_one, *line_two;
X{
X WINDOW *e_win, *newwin();
X void cleanup(), status_line();
X
X e_win = newwin(7, 70, 9, 5);
X /* display the nasty note */
X mvwaddstr(e_win, 2, 4, line_one);
X mvwaddstr(e_win, 3, 4, line_two);
X box(e_win, '|', '-');
X
X if (code) {
X mvwattrstr(e_win, 0, 4, A_BOLD, " Error ");
X mvwattrstr(e_win, 5, 24, A_BLINK, "Press any key to exit");
X wmove(e_win, 5, 46);
X }
X else {
X mvwattrstr(e_win, 0, 4, A_BOLD, " Warning ");
X mvwattrstr(e_win, 5, 22, A_BLINK, "Press any key to continue");
X wmove(e_win, 5, 48);
X }
X beep();
X wrefresh(e_win);
X
X wgetch(e_win);
X werase(e_win);
X wrefresh(e_win);
X delwin(e_win);
X
X if (code) {
X /*
X * Since this routine gets called if there is an error reading
X * the support files, the dir and param structures can't be
X * guaranteed to exist yet.
X */
X if (dir != NULL && param != NULL)
X status_line(" exiting");
X cleanup(code);
X }
X return;
X}
SHAR_EOF
if test 2142 -ne "`wc -c < 'pexit.c'`"
then
echo shar: "error transmitting 'pexit.c'" '(should have been 2142 characters)'
fi
fi
echo shar: "extracting 'port.c'" '(6122 characters)'
if test -f 'port.c'
then
echo shar: "will not over-write existing file 'port.c'"
else
sed 's/^X//' << \SHAR_EOF > 'port.c'
X/*
X * Routines to get or release a tty port.
X */
X
X#define LOCKDIR "/usr/spool/uucp"
X#undef ASCII_PID
X
X#include <stdio.h>
X#include <fcntl.h>
X#include <termio.h>
X#ifdef UNIXPC
X#include <sys/phone.h>
X#endif /* UNIXPC */
X#include "dial_dir.h"
X#include "modem.h"
X#include "status.h"
X
Xint getty_status;
X/*
X * Finds a free (or requested) serial port. Creates a lock file to hold
X * it for our use. Loads the modem database. A return code of 1 means
X * all ports (or the requested port) are busy.
X */
X
Xint
Xget_port()
X{
X int i, j, k, progpid, fd, list[NUM_TTY];
X char file[80], buf[80], message[80], *strdup();
X void error_win(), line_set(), release_port(), send_str();
X void free_ptr();
X
X /*
X * If we already have a port, see if it is good enough for the
X * current request.
X */
X if (status->fd != -1) {
X if (!strcmp(dir->index[dir->d_cur], modem->tty[modem->t_cur]) ||
X modem->mbaud[modem->t_cur] >= dir->baud[dir->d_cur]) {
X /*
X * Re-initialize the modem because the baud
X * rate (or other parameters) may have changed.
X */
X line_set();
X send_str(modem->init[modem->m_cur]);
X return(0);
X }
X }
X release_port(1);
X
X /*
X * See if you want a specific tty port. If the index field in the
X * dialing directory is a valid device name, then use that tty.
X */
X sprintf(buf, "/dev/%s", dir->index[dir->d_cur]);
X list[0] = -1;
X /* if index is a valid device */
X if (!access(buf, 0)) {
X for (i=0; i<modem->t_entries; i++) {
X /* and it exists in modem database */
X if (!strcmp(dir->index[dir->d_cur], modem->tty[i])) {
X list[0] = i;
X list[1] = -1;
X break;
X }
X }
X }
X
X /*
X * Create a list of acceptable ttys. It searches the tty database
X * for the requested baud rate.
X */
X k = 0;
X if (list[0] == -1) {
X for (i=0; i<modem->t_entries; i++) {
X /* skip ports with no modems */
X if (!strcmp(modem->tname[i], "DIRECT"))
X continue;
X
X /* can handle requested baud rate ? */
X if (modem->mbaud[i] >= dir->baud[dir->d_cur])
X list[k++] = i;
X }
X /* the end of list marker */
X list[k] = -1;
X }
X /* empty list ? */
X if (list[0] == -1) {
X sprintf(message, "No modem at a %d baud rating exists in", dir->baud[dir->d_cur]);
X sprintf(file, "modem file '%s'", status->m_path);
X error_win(0, message, file);
X return(1);
X }
X /* check the list for a free port */
X i = 0;
X while (list[i] != -1) {
X /* create a lock file name */
X sprintf(file, "%s/LCK..%s", LOCKDIR, modem->tty[list[i]]);
X
X /*
X * See if the lock file exists... We DO NOT look to see
X * if the pid in the file is still active. Maybe I'll
X * change this later...
X */
X if (access(file, 0)) {
X getty_status = set_getty(modem->tty[list[i]], 0);
X
X if ((fd = open(file, O_CREAT|O_WRONLY, 0666)) < 0) {
X set_getty(modem->tty[list[i]], 1);
X sprintf(buf, "'%s'", file);
X error_win(1, "Can't create the lockfile", buf);
X }
X#ifdef ASCII_PID
X sprintf(buf, "%10d\n", getpid());
X write(fd, buf, 11);
X#else /* ASCII_PID */
X progpid = getpid();
X write(fd, (char *)&progpid, sizeof(int));
X#endif /* ASCII_PID */
X close(fd);
X /* store the new values */
X free_ptr(status->lock_path);
X status->lock_path = strdup(file);
X modem->t_cur = list[i];
X
X /* open the device (hold DTR high) */
X sprintf(buf, "/dev/%s", modem->tty[list[i]]);
X if ((fd = open(buf, O_RDWR|O_NDELAY)) < 0) {
X set_getty(modem->tty[list[i]], 1);
X sprintf(file, "Can't open port '%s' for read and write", buf);
X error_win(1, file, NULL);
X }
X
X /* turn off the "no delay" mode */
X fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) & ~O_NDELAY);
X status->fd = fd;
X /* change line settings */
X line_set();
X /* load the modem data base */
X for (j=0; j<modem->m_entries; j++) {
X if (!strcmp(modem->tname[list[i]], modem->mname[j])) {
X modem->m_cur = j;
X break;
X }
X }
X /* initialize the modem */
X send_str(modem->init[j]);
X return(0);
X }
X i++;
X }
X error_win(0, "All ports are busy now, try again later", NULL);
X return(1);
X}
X
X/*
X * Release the port. Closes the file descriptor and removes the
X * lock file
X */
X
Xvoid
Xrelease_port(verbose)
Xint verbose;
X{
X char buf[80];
X extern char *null_ptr;
X void free_ptr(), hang_up();
X
X /*
X * The modem structure can't be guaranteed to exist yet. For example,
X * an error in reading one of the other support files would cause
X * this routine to be used before the MODEM structure gets allocated.
X */
X if (modem == NULL)
X return;
X /* close the port */
X if (status->fd != -1) {
X ioctl(status->fd, TCFLSH, 2);
X /*
X * Since HUPCL is set, the close() should drop the DTR and
X * hang up the modem (provided you've got the modem to
X * respond to DTR). Since this is not guaranteed, we send
X * the hangup string first.
X */
X hang_up(verbose);
X close(status->fd);
X }
X /* remove the lock */
X if (*status->lock_path != NULL) {
X if (unlink(status->lock_path)) {
X sprintf(buf, "'%s'", status->lock_path);
X error_win(0, "Can't remove the lock file", buf);
X }
X free_ptr(status->lock_path);
X status->lock_path = null_ptr;
X }
X /* turn the getty back on? */
X if (getty_status)
X set_getty(modem->tty[modem->t_cur], 1);
X /* cleanup the structure */
X status->fd = -1;
X modem->m_cur = -1;
X modem->t_cur = -1;
X return;
X}
X
X/*
X * Turn the /etc/getty on or off for the specified port. A return code
X * of 1 means that the getty was on. Systems with uugetty or dedicated
X * dialout ports won't need this routine.
X */
X
Xint
Xset_getty(tty, on)
Xchar *tty;
Xint on;
X{
X#ifdef UNIXPC
X int i, ret_code;
X char buf[40];
X unsigned int sleep();
X /* the last three characters */
X i = strlen(tty) -3;
X
X ret_code = 0;
X if (on) {
X sprintf(buf, "setgetty %s 1", tty+i);
X system(buf);
X }
X else {
X sprintf(buf, "setgetty %s 0", tty+i);
X if (system(buf) == 512)
X ret_code = 1;
X sleep(1);
X }
X return(ret_code);
X#else /* UNIXPC */
X /*
X * If you don't have one of these cute little routines, you
X * might wanna write one. It should check for an existing lock
X * file, edit the /etc/inittab file, and issue an init -q.
X * Obviously the program would be suid to root.
X */
X return(0);
X#endif /* UNIXPC */
X}
SHAR_EOF
if test 6122 -ne "`wc -c < 'port.c'`"
then
echo shar: "error transmitting 'port.c'" '(should have been 6122 characters)'
fi
fi
echo shar: "extracting 'redial.c'" '(2216 characters)'
if test -f 'redial.c'
then
echo shar: "will not over-write existing file 'redial.c'"
else
sed 's/^X//' << \SHAR_EOF > 'redial.c'
X/*
X * The redial option (actually a misnomer, it's really a queuing system).
X * We expect a space-separated list of dialing directory entries (although
X * new users always try to put in a phone number). A return code of 1
X * means we're ready to dial.
X */
X
X#include <stdio.h>
X#include <curses.h>
X#include "dial_dir.h"
X#include "misc.h"
X
Xint
Xredial(fd)
Xint fd;
X{
X WINDOW *rd_win, *newwin();
X char *ans, *entry, *get_str(), *strchr(), *strtok();
X int i, oops, number, ret_code;
X
X rd_win = newwin(6, 70, 5, 5);
X
X mvwaddstr(rd_win, 4, 23, "(CR for previous numbers)");
X mvwaddstr(rd_win, 2, 4, "Directory Entry Number(s): ");
X box(rd_win, '|', '-');
X
X mvwattrstr(rd_win, 0, 3, A_BOLD, " Redial Queue ");
X wmove(rd_win, 2, 31);
X wrefresh(rd_win);
X /* get the string of numbers */
X ret_code = 0;
X while ((ans = get_str(rd_win, 35, "0123456789+-@# ", NULL)) != NULL) {
X oops = 0;
X if (*ans == NULL) {
X /* use previous queue */
X if (dir->q_num[0] != -1) {
X ret_code = 1;
X break;
X }
X /* there is no previous queue */
X beep();
X mvwattrstr(rd_win, 3, 4, A_BOLD, "No previous numbers");
X wrefresh(rd_win);
X wait_key(rd_win, 3);
X clear_line(rd_win, 3, 4, 1);
X wmove(rd_win, 2, 31);
X wrefresh(rd_win);
X continue;
X }
X /* parse the queue values */
X entry = strtok(ans, " ");
X for (i=0; i<NUM_QUEUE; i++) {
X if (*entry == NULL) {
X dir->q_num[i] = -1;
X continue;
X }
X /* is there a LD code ? */
X dir->q_ld[i] = NULL;
X if (strchr("+-@#", *entry)) {
X dir->q_ld[i] = *entry;
X entry++;
X }
X
X /*
X * Zero is valid here, because it means use
X * the current entry information.
X */
X number = atoi(entry);
X if (number < -1 || number > NUM_DIR) {
X beep();
X mvwattrstr(rd_win, 3, 4, A_BOLD, "Invalid directory entry number");
X wrefresh(rd_win);
X wait_key(rd_win, 3);
X clear_line(rd_win, 3, 4, 1);
X clear_line(rd_win, 2, 31, 1);
X wrefresh(rd_win);
X oops++;
X break;
X }
X /* store the number in the queue */
X dir->q_num[i] = number;
X entry = strtok((char *) NULL, " ");
X }
X if (oops)
X continue;
X ret_code = 1;
X break;
X }
X if (fd == -1) {
X werase(rd_win);
X wrefresh(rd_win);
X }
X delwin(rd_win);
X return(ret_code);
X}
SHAR_EOF
if test 2216 -ne "`wc -c < 'redial.c'`"
then
echo shar: "error transmitting 'redial.c'" '(should have been 2216 characters)'
fi
fi
exit 0
# End of shell archive
--
Please send comp.sources.unix-related mail to rsalz@uunet.uu.net.