Pcomm v1.1 (4 of 8)

Emmet Gray egray at killer.DALLAS.TX.US
Sun Sep 4 07:32:30 AEST 1988


This is part 4 (of 8) to the Pcomm v1.1 release package.

Emmet P. Gray				US Army, HQ III Corps & Fort Hood
..!uunet!uiucuxc!fthood!egray		Attn: AFZF-DE-ENV
					DEH, Environmental Management Office
					Fort Hood, TX 76544-5057

------------------------------------------------------------------------------
#! /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:
#	di_win.c
#	dial.c
#	expand.c
#	getcwd.c
#	getopt.c
#	help.c
#	info.c
#	init.c
#	input.c
#	line_set.c
#	list_dir.c
#	ls_menu.c
# This archive created: Sat Sep  3 15:34:58 1988
export PATH; PATH=/bin:/usr/bin:$PATH
echo shar: "extracting 'di_win.c'" '(9165 characters)'
if test -f 'di_win.c'
then
	echo shar: "will not over-write existing file 'di_win.c'"
else
sed 's/^X//' << \SHAR_EOF > 'di_win.c'
X/*
X * The dialing window routines.
X */
X
X#define MAX_PASS 25
X
X#include <stdio.h>
X#include <curses.h>
X#include "config.h"
X#include "dial_dir.h"
X#include "misc.h"
X#include "modem.h"
X#include "param.h"
X
X/*
X * The dialing window.  Its job is to kill the input routine, get a port,
X * cycle thru the entries in the queue, while interpreting both the
X * user's requests and the modem's responses.  A return code of 1 means
X * we're ready to fire up the input routine.
X */
X
Xint
Xdial_win()
X{
X	extern int rc_index, fd;
X	WINDOW *di_win, *newwin();
X	int i, j, key, want_out, pass, tic, baud;
X	long now, time();
X	char *tbuf, *ctime(), *str, cr=13, *read_codes();
X	void disp_queue(), send_str(), dial_it(), delay_times(), input_off();
X	void error_win(), line_set(), hang_up(), zap_vs(), log_calls();
X	void st_line();
X	unsigned int sleep();
X					/* are we already talking? */
X	input_off();
X	hang_up(1);
X
X	touchwin(stdscr);
X	refresh();
X
X	if (get_port())
X		return(0);
X	/*
X	 * If the phone number is a NULL, then either we are on a
X	 * direct line, or you want to do the dialing yourself.
X	 */
X	if (*dir->number[dir->q_num[0]] == NULL) {
X					/* check LD permission */
X		if (limit_ld(0))
X			return(0);
X					/* can't talk directly to OBM */
X		if (!strcmp(modem->mname[modem->m_cur], "OBM")) {
X			error_win(0, "Can't access the On Board Modem directly",
X			 "You must use the automatic dialing feature");
X			return(0);
X		}
X
X		zap_vs();
X		touchwin(stdscr);
X		clear();
X		printw("Connected to /dev/%s at %d baud...\n", modem->tty[modem->t_cur], dir->baud[dir->d_cur]);
X		refresh();
X		return(1);
X	}
X
X	di_win = newwin(17, 70, 3, 5);
X					/* the basic window */
X	mvwattrstr(di_win, 1, 20, A_BOLD, "D I A L I N G       W I N D O W");
X	horizontal(di_win, 2, 0, 70);
X	mvwaddstr(di_win, 4, 23, "System name:");
X	mvwaddstr(di_win, 5, 23, "Pass number:");
X	mvwaddstr(di_win, 6, 14, "Elapse time this try:");
X	mvwaddstr(di_win, 7, 13, "Time at start of dial:");
X	mvwaddstr(di_win, 8, 9, "Time at start of this try:");
X	mvwaddstr(di_win, 9, 16, "Connect delay time:");
X	mvwaddstr(di_win, 10, 17, "Redial delay time:");
X	mvwaddstr(di_win, 11, 25, "Index/TTY:");
X	mvwaddstr(di_win, 12, 16, "Result of last try:");
X
X	mvwaddstr(di_win, 14, 3, "<SPACE>: Recycle");
X	mvwaddstr(di_win, 14, 22, "<DEL>: Remove from queue");
X	mvwaddstr(di_win, 14, 49, "E: Change delays");
X
X					/* the start time */
X	time(&now);
X	tbuf = ctime(&now);
X	tbuf[19] = NULL;
X	mvwaddstr(di_win, 7, 36, &tbuf[11]);
X
X	mvwprintw(di_win, 9, 36, "%-4d", param->c_delay);
X	mvwprintw(di_win, 10, 36, "%-4d", param->r_delay);
X
X	box(di_win, VERT, HORZ);
X	mvwaddstr(di_win, 16, 24, " Press <ESC> to abort ");
X
X	pass = 0;
X	i = 0;
X	want_out = 0;
X	while (!want_out && pass <= MAX_PASS) {
X		key = -1;
X		pass++;
X					/* update the d_cur variable */
X		dir->d_cur = dir->q_num[i];
X					/* check LD permission */
X		if (limit_ld(i)) {
X			want_out++;
X			break;
X		}
X					/* get a port */
X		if (get_port()) {
X			want_out++;
X			break;
X		}
X					/* fill in the window */
X		disp_queue(di_win, dir->d_cur, pass);
X
X		/*
X		 * The actual dial routine.  The "i" is the index into the
X		 * queue, not the entry number.  Returns immediately without
X		 * waiting for a carrier.
X		 */
X		dial_it(i);
X		ioctl(fd, TCFLSH, 0);
X
X		/*
X		 * Here we do a time-slice between reading the result codes
X		 * from the modem and reading the keyboard.  The one second
X		 * granularity won't be too accurate, but who cares?
X		 */
X		tic = 0;
X		rc_index = 0;
X		while (tic < param->c_delay) {
X			if ((str = read_codes()) == NULL) {
X				mvwprintw(di_win, 6, 36, "%-4d", ++tic);
X				wrefresh(di_win);
X			}
X			else {
X				/*
X				 * A return code that converts to an number
X				 * that is less than 300 is probably an error
X				 * message.
X				 */
X				baud = atoi(str);
X				if (baud < 300) {
X					mvwprintw(di_win, 12, 36, "%-20.20s", str);
X					wmove(di_win, 12, 36);
X					wrefresh(di_win);
X					break;
X				}
X					/* we're connected */
X				beep();
X				clear_line(di_win, 12, 36, 1);
X				wattrstr(di_win, A_BLINK, "CONNECTED");
X				wmove(di_win, 12, 36);
X				wrefresh(di_win);
X				wait_key(di_win, 2);
X				delwin(di_win);
X
X				/*
X				 * Did the modem sync at a different baud
X				 * rate than what we expected?
X				 */
X				if (dir->baud[dir->d_cur] != baud) {
X					if (can_sync(baud)) {
X						dir->baud[dir->d_cur] = baud;
X						line_set();
X					}
X				}
X
X				zap_vs();
X				touchwin(stdscr);
X				clear();
X				printw("Connected to %s at %d baud...\n",
X				 dir->name[dir->d_cur], dir->baud[dir->d_cur]);
X				refresh();
X
X					/* log the call */
X				log_calls(i);
X				return(1);
X			}
X			if (tic == param->c_delay)
X				break;
X					/* ok... try the keyboard */
X			if ((key = wait_key(di_win, 1)) != -1)
X				break;
X
X			mvwprintw(di_win, 6, 36, "%-4d", ++tic);
X			wrefresh(di_win);
X		}
X		/*
X		 * If the modem did not return a code, then we need to
X		 * stop it.  Sending a CR will stop most modems cold,
X		 * except of course for the OBM...
X		 */
X		if (str == NULL) {
X			if (!strcmp(modem->mname[modem->m_cur], "OBM"))
X				hang_up(0);
X			else
X				write(fd, &cr, 1);
X			sleep(1);
X		}
X					/* if we get here, no key was pressed */
X		if (key == -1) {
X			clear_line(di_win, 6, 14, 1);
X			mvwaddstr(di_win, 6, 27, "Pausing:");
X					/* no return code? */
X			if (str == NULL) {
X				clear_line(di_win, 12, 36, 1);
X				waddstr(di_win, "TIMED OUT");
X				wmove(di_win, 12, 36);
X			}
X					/* do the pause */
X			tic = 0;
X			while (tic < param->r_delay) {
X				if ((key = wait_key(di_win, 1)) != -1)
X					break;
X				mvwprintw(di_win, 6, 36, "%-4d", ++tic);
X				wrefresh(di_win);
X			}
X			clear_line(di_win, 6, 14, 1);
X			waddstr(di_win, "Elapse time this try:");
X		}
X		mvwaddstr(di_win, 6, 36, "0   ");
X					/* Process the keystroke */
X		switch (key) {
X			case ' ':	/* next in the queue */
X				clear_line(di_win, 12, 36, 1);
X				waddstr(di_win, "RECYCLED");
X				wmove(di_win, 12, 36);
X				wrefresh(di_win);
X				/* fall thru... */
X			case -1:	/* no key was pressed */
X				i++;
X				if (i > NUM_QUEUE)
X					i = 0;
X				if (dir->q_num[i] == -1)
X					i = 0;
X				break;
X			case DEL:	/* <DEL> key, remove from queue */
X				if (dir->q_num[1] == -1) {
X					beep();
X					clear_line(di_win, 12, 36, 1);
X					waddstr(di_win, "NO MORE ENTRIES");
X					wmove(di_win, 12, 36);
X					wrefresh(di_win);
X					wait_key(di_win, 3);
X					break;
X				}
X				clear_line(di_win, 12, 36, 1);
X				waddstr(di_win, "ENTRY DELETED");
X				wmove(di_win, 12, 36);
X				wrefresh(di_win);
X				wait_key(di_win, 3);
X
X					/* compact the queue */
X				for (j=i; j<NUM_QUEUE-1; j++)
X					dir->q_num[j] = dir->q_num[j+1];
X				dir->q_num[NUM_QUEUE-1] = -1;
X				break;
X			case 'e':
X			case 'E':	/* change delay time */
X				delay_times();
X				touchwin(di_win);
X				mvwprintw(di_win, 9, 36, "%-4d", param->c_delay);
X				mvwprintw(di_win, 10, 36, "%-4d", param->r_delay);
X				break;
X			case ESC:	/* <ESC> key */
X				beep();
X				clear_line(di_win, 12, 36, 1);
X				wattrstr(di_win, A_BLINK, "DIAL ABORTED");
X				wmove(di_win, 12, 36);
X				wrefresh(di_win);
X				wait_key(di_win, 3);
X				want_out++;
X				break;
X			default:
X				beep();
X				break;
X		}
X	}
X					/* clean up and go home */
X	werase(di_win);
X	wrefresh(di_win);
X	delwin(di_win);
X	if (!want_out)
X		error_win(0, "Exceeded the maximum number number of dialing attempts", "");
X	return(0);
X}
X
X/*
X * Display what info we know at this time.
X */
X
Xstatic void
Xdisp_queue(win, entry, pass)
XWINDOW *win;
Xint entry, pass;
X{
X	long now, time();
X	char *tbuf, *ctime();
X	void st_line();
X					/* redo the status line */
X	st_line("");
X					/* system name */
X	clear_line(win, 4, 36, 1);
X	waddstr(win, dir->name[entry]);
X					/* pass number */
X	mvwprintw(win, 5, 36, "%-4d", pass);
X					/* time of this call */
X	time(&now);
X	tbuf = ctime(&now);
X	tbuf[19] = NULL;
X	mvwaddstr(win, 8, 36, &tbuf[11]);
X					/* the index field */
X	clear_line(win, 11, 36, 1);
X	waddstr(win, dir->index[entry]);
X
X	wmove(win, 12, 36);
X	wrefresh(win);
X	return;
X}
X
X/*
X * Determine if the modem can detect the synchronization of the connected
X * baud rate.  We check the modem database and see if the connect string
X * is unique.  A return code of 1 means the modem can sync.
X */
X
Xstatic int
Xcan_sync(baud)
Xint baud;
X{
X	int i;
X	char *str;
X					/* feature disabled? */
X	if (modem->auto_baud[modem->m_cur] != 'Y')
X		return(0);
X					/* re-construct the string */
X	switch (baud) {
X		case 300:
X			str = modem->con_3[modem->m_cur];
X			break;
X		case 1200:
X			str = modem->con_12[modem->m_cur];
X			break;
X		case 2400:
X			str = modem->con_24[modem->m_cur];
X			break;
X		case 4800:
X			str = modem->con_48[modem->m_cur];
X			break;
X		case 9600:
X			str = modem->con_96[modem->m_cur];
X			break;
X		case 19200:
X			str = modem->con_192[modem->m_cur];
X			break;
X		default:
X			return(0);
X	}
X
X	if (*str == NULL)
X		return(0);
X					/* test "str" against all others */
X	i = 0;
X	if (!strcmp(str, modem->con_3[modem->m_cur]))
X		i++;
X	if (!strcmp(str, modem->con_12[modem->m_cur]))
X		i++;
X	if (!strcmp(str, modem->con_24[modem->m_cur]))
X		i++;
X	if (!strcmp(str, modem->con_48[modem->m_cur]))
X		i++;
X	if (!strcmp(str, modem->con_96[modem->m_cur]))
X		i++;
X	if (!strcmp(str, modem->con_192[modem->m_cur]))
X		i++;
X					/* should match only itself */
X	if (i == 1)
X		return(1);
X	return(0);
X}
SHAR_EOF
if test 9165 -ne "`wc -c < 'di_win.c'`"
then
	echo shar: "error transmitting 'di_win.c'" '(should have been 9165 characters)'
fi
fi
echo shar: "extracting 'dial.c'" '(7336 characters)'
if test -f 'dial.c'
then
	echo shar: "will not over-write existing file 'dial.c'"
else
sed 's/^X//' << \SHAR_EOF > 'dial.c'
X/*
X * The routines that dial the modem and listen for the return codes.
X */
X
X#include <stdio.h>
X#include <termio.h>
X#include "config.h"
X#ifdef UNIXPC
X#include <sys/phone.h>
X#endif /* UNIXPC */
X#include "dial_dir.h"
X#include "misc.h"
X#include "modem.h"
X#include "param.h"
X
X/*
X * Get the dial string ready, send it to the modem.  The parameter is not
X * the actual entry number, it is an index into the queue.
X */
X
Xvoid
Xdial_it(num)
Xint num;
X{
X	extern int fd;
X	int i, skip;
X	char s[100], number[40], *strcpy(), *strcat(), *n, *strchr();
X	void send_str();
X#ifdef UNIXPC
X	struct updata pbuf;
X	unsigned int sleep();
X#endif /* UNIXPC */
X
X	/*
X	 * Create the string to be sent to the modem.  The long distance
X	 * codes are added if they are requested.
X	 */
X	s[0] = NULL;
X	strcpy(s, modem->dial[modem->m_cur]);
X
X	switch (dir->q_ld[num]) {
X		case 0:			/* no ld code requested */
X			break;
X		case '+':
X			strcat(s, param->ld_plus);
X			break;
X		case '-':
X			strcat(s, param->ld_minus);
X			break;
X		case '@':
X			strcat(s, param->ld_at);
X			break;
X		case '#':
X			strcat(s, param->ld_pound);
X			break;
X	}
X	/*
X	 * Purify the phone number by removing all the pretty characters
X	 * that don't need to be sent to the modem.  Typically the "-",
X	 * "(", ")", and space characters are just for looks.  To prevent
X	 * this action, prepend a "\" to the character.
X	 */
X	i = 0;
X	skip = 0;
X	n = dir->number[dir->q_num[num]];
X	while (*n) {
X		if (*n == '\\' && !skip) {
X			skip++;
X			n++;
X			continue;
X		}
X		if (!strchr("-() ", *n) || skip)
X			number[i++] = *n;
X		n++;
X		skip = 0;
X	}
X	number[i] = NULL;
X					/* add it to the string */
X	strcat(s, number);
X	strcat(s, modem->suffix[modem->m_cur]);
X#ifdef DEBUG
X	fprintf(stderr, "raw dial string: '%s'\n", s);
X#endif /* DEBUG */
X
X#ifdef UNIXPC
X					/* special case for OBM */
X	if (!strcmp(modem->mname[modem->m_cur], "OBM")) {
X					/* prepare the modem */
X		pbuf.c_lineparam = DATA|DTMF;
X		pbuf.c_waitdialtone = 5;
X		pbuf.c_linestatus = 0;
X		pbuf.c_feedback = SPEAKERON|NORMSPK;
X		pbuf.c_waitflash = 500;
X		ioctl(fd, PIOCSETP, &pbuf);
X		sleep(1);
X					/* connect the dialer */
X		ioctl(fd, PIOCRECONN);
X		sleep(1);
X					/* dial each digit */
X		n = s;
X		while (*n) {
X					/* switch tone/pulse dialing? */
X			switch (*n) {
X				case '^':
X					pbuf.c_lineparam = DATA|PULSE;
X					ioctl(fd, PIOCSETP, &pbuf);
X					break;
X				case '%':
X					pbuf.c_lineparam = DATA|DTMF;
X					ioctl(fd, PIOCSETP, &pbuf);
X					break;
X				default:
X					ioctl(fd, PIOCDIAL, n);
X					break;
X			}
X			n++;
X		}
X		return;
X	}
X#endif /* UNIXPC */
X
X	send_str(s);
X	return;
X}
X
X/*
X * Send a string to the modem.  Performs all the character synonym
X * translations.  No sanity checking on the "m_cur" value.
X */
X
Xvoid
Xsend_str(s)
Xchar *s;
X{
X	extern int fd;
X	int skip;
X	unsigned int sleep();
X					/* empty string? */
X	if (s == NULL || *s == NULL)
X		return;
X
X	ioctl(fd, TCFLSH, 1);
X	/*
X	 * Change the character synonyms to their real values.  Writes
X	 * the characters to the modem.  To remove the special meaning
X	 * of one of the characters, prepend a "\" to it.
X	 */
X	skip = 0;
X	while (*s) {
X					/* send the literal character */
X		if (skip) {
X			skip = 0;
X			write(fd, s, 1);
X			ioctl(fd, TCSBRK, 1);
X#ifdef DEBUG
X			fprintf(stderr, "send_str: '%c', %02x, %03o, %d\n", *s, *s, *s, *s);
X#endif /* DEBUG */
X			s++;
X			continue;
X		}
X					/* turn off the special meaning */
X		if (*s == '\\') {
X			skip++;
X			s++;
X			continue;
X		}
X					/* pause synonym */
X		if (*s == param->pause_char) {
X			sleep(1);
X			s++;
X			continue;
X		}
X					/* carriage return synonym */
X		if (*s == param->cr_char)
X			*s = '\r';
X					/* 2 character control sequence */
X		if (*s == param->ctrl_char) {
X			s++;
X					/* premature EOF? */
X			if (*s == NULL)
X				break;
X					/* upper and lower case */
X			if (*s > '_')
X				*s -= 96;
X			else
X				*s -= 64;
X		}
X					/* escape synonym */
X		if (*s == param->esc_char)
X			*s = ESC;
X					/* modem break synonym */
X		if (*s == param->brk_char) {
X			ioctl(fd, TCSBRK, 0);
X			sleep(1);
X			s++;
X			continue;
X		}
X
X		write(fd, s, 1);
X#ifdef DEBUG
X		fprintf(stderr, "send_str: '%c', %02x, %03o, %d\n", *s, *s, *s, *s);
X#endif /* DEBUG */
X		/*
X		 * Because the pause char makes the timing critical, we
X		 * wait until the buffer is clear before we continue.
X		 */
X		ioctl(fd, TCSBRK, 1);
X		s++;
X	}
X	return;
X}
X
X/*
X * Read the result codes coming back from the modem.  Test for the 6
X * "connect" strings and the 4 "no connect" strings.  Return the connected
X * baud rate (as a string) or the error message.
X */
X
Xchar rc_buf[512];
Xint rc_index;
X
Xchar *
Xread_codes()
X{
X	extern int fd;
X	char c;
X#ifdef UNIXPC
X	unsigned int sleep();
X	struct updata pbuf;
X					/* special case for OBM */
X	if (!strcmp(modem->mname[modem->m_cur], "OBM")) {
X		ioctl(fd, PIOCGETP, &pbuf);
X
X		/*
X		 * The OBM doesn't use a return message to announce the
X		 * connection to a remote, so we fake one.  The 1200
X		 * is quite arbitrary... it is not an indicator of the
X		 * connected baud rate.
X		 */
X		if (pbuf.c_linestatus & MODEMCONNECTED)
X			return("1200");
X
X		sleep(1);
X		return(NULL);
X	}
X#endif /* UNIXPC */
X					/* search for key words */
X	for (; rc_index<511; rc_index++) {
X		if ((int) (c = getc_line(1)) <= 0)
X			return(NULL);
X#ifdef DEBUG
X		fprintf(stderr, "read_codes: '%c', %02x, %03o, %d\n", c, c, c, c);
X#endif /* DEBUG */
X
X		rc_buf[rc_index] = c;
X		rc_buf[rc_index+1] = NULL;
X					/* the connect strings */
X		if (match(rc_buf, modem->con_3[modem->m_cur]))
X			return("300");
X
X		if (match(rc_buf, modem->con_12[modem->m_cur]))
X			return("1200");
X
X		if (match(rc_buf, modem->con_24[modem->m_cur]))
X			return("2400");
X
X		if (match(rc_buf, modem->con_48[modem->m_cur]))
X			return("4800");
X
X		if (match(rc_buf, modem->con_96[modem->m_cur]))
X			return("9600");
X
X		if (match(rc_buf, modem->con_192[modem->m_cur]))
X			return("19200");
X
X					/* the no connect strings */
X		if (match(rc_buf, modem->no_con1[modem->m_cur]))
X			return(modem->no_con1[modem->m_cur]);
X
X		if (match(rc_buf, modem->no_con2[modem->m_cur]))
X			return(modem->no_con2[modem->m_cur]);
X
X		if (match(rc_buf, modem->no_con3[modem->m_cur]))
X			return(modem->no_con3[modem->m_cur]);
X
X		if (match(rc_buf, modem->no_con4[modem->m_cur]))
X			return(modem->no_con4[modem->m_cur]);
X	}
X					/* ran out of buffer? */
X	return("ERROR");
X}
X
X/*
X * Test for a match between two character strings.  A return code of 1
X * means that s2 was found at the end of s1.
X */
X
Xstatic int
Xmatch(s1, s2)
Xchar *s1, *s2;
X{
X	register int i;
X	int skip, diff;
X	char new[40];
X					/* if no string to match */
X	if (*s2 == NULL)
X		return(0);
X					/* translate synonyms */
X	i = 0;
X	skip = 0;
X	while (*s2) {
X					/* literal character */
X		if (skip) {
X			skip = 0;
X			new[i++] = *s2;
X			s2++;
X			continue;
X		}
X					/* turn off the special meaning */
X		if (*s2 == '\\') {
X			skip++;
X			s2++;
X			continue;
X		}
X					/* carriage return synonym */
X		if (*s2 == param->cr_char)
X			*s2 = '\r';
X
X					/* 2 character control sequence */
X		if (*s2 == param->ctrl_char) {
X			s2++;
X			if (*s2 == NULL)
X				break;
X			if (*s2 > '_')
X				*s2 -= 96;
X			else
X				*s2 -= 64;
X		}
X					/* escape synonym */
X		if (*s2 == param->esc_char)
X			*s2 = ESC;
X
X		new[i++] = *s2;
X		s2++;
X	}
X	new[i] = NULL;
X
X	diff = strlen(s1) - strlen(new);
X					/* is it possible? */
X	if (diff < 0)
X		return(0);
X					/* test it out */
X	if (!strcmp(&s1[diff], new))
X		return(1);
X	return(0);
X}
SHAR_EOF
if test 7336 -ne "`wc -c < 'dial.c'`"
then
	echo shar: "error transmitting 'dial.c'" '(should have been 7336 characters)'
fi
fi
echo shar: "extracting 'expand.c'" '(2683 characters)'
if test -f 'expand.c'
then
	echo shar: "will not over-write existing file 'expand.c'"
else
sed 's/^X//' << \SHAR_EOF > 'expand.c'
X/*
X * Do file name expansion with "native" shell.  Using the native shell
X * (as described in the SHELL environmental variable) allows for csh or
X * ksh abbreviations that sh doesn't recognize.
X */
X
X#include <stdio.h>
X#include <signal.h>
X#include <fcntl.h>
X#include "config.h"
X
Xchar *
Xexpand(input)
Xchar *input;
X{
X	extern char *null_ptr;
X	FILE *pfp, *n_popen();
X	int last;
X	char *ans, buf[1024], *strpbrk(), *strdup();
X	void free_ptr();
X
X					/* same rules as strdup() */
X	if (input == NULL)
X		return(NULL);
X	if (*input == NULL)
X		return(null_ptr);
X					/* any thing to expand? */
X	ans = strdup(input);
X	if (!strpbrk(input, "$*{}[]\\?~"))
X		return(ans);
X					/* popen an echo */
X	sprintf(buf, "echo %s", input);
X
X	pfp = n_popen(buf, "r");
X	fgets(buf, 1024, pfp);
X	n_pclose(pfp);
X
X	if (!strlen(buf))
X		return(ans);
X	/*
X	 * A horrible kludge...  if the last character is not a line
X	 * feed, then the csh has returned an error message.  Otherwise
X	 * zap the line feed.
X	 */
X	last = strlen(buf) -1;
X	if (buf[last] != '\n')
X		return(ans);
X	else
X		buf[last] = NULL;
X
X	free_ptr(ans);
X	ans = strdup(buf);
X	return(ans);
X}
X
X#define	tst(a,b) (*mode == 'r'? (b) : (a))
X#define	RDR	0
X#define	WTR	1
Xstatic int popen_pid[20];
X
XFILE *
Xn_popen(cmd, mode)
Xchar *cmd, *mode;
X{
X	int myside, hisside, ppid, p[2];
X	char *shellpath, *shell, *flags, *getenv(), *strrchr();
X	void _exit();
X
X	if (pipe(p) < 0)
X		return NULL;
X
X	myside = tst(p[WTR], p[RDR]);
X	hisside = tst(p[RDR], p[WTR]);
X					/* get the environmental variable */
X	shellpath = getenv("SHELL");
X	if (shellpath == NULL || *shellpath == NULL)
X		shellpath = "/bin/sh";
X
X	shell = strrchr(shellpath, '/') + 1;
X					/* fix up the flags */
X	if (!strcmp(shell, "csh"))
X		flags = "-fc";
X	else
X		flags = "-c";		/* Korn shell too */
X
X	if (!(ppid = fork())) {
X		int stdio;
X					/* no error messages please */
X		close(2);
X		open("/dev/null", O_WRONLY);
X#ifdef SETUGID
X		setgid(getgid());
X		setuid(getuid());
X#endif /* SETUGID */
X		stdio = tst(0, 1);
X		close(myside);
X		close(stdio);
X		fcntl(hisside, F_DUPFD, stdio);
X		close(hisside);
X		execl(shellpath, shell, flags, cmd, (char *) 0);
X		_exit(1);
X	}
X	if (ppid == -1) {
X		close(myside);
X		close(hisside);
X		return NULL;
X	}
X
X	popen_pid[myside] = ppid;
X
X	close(hisside);
X	return(fdopen(myside, mode));
X}
X
Xn_pclose(ptr)
XFILE *ptr;
X{
X	int f, r, (*hstat)(), (*istat)(), (*qstat)(), status;
X
X	f = fileno(ptr);
X	fclose(ptr);
X	istat = signal(SIGINT, SIG_IGN);
X	qstat = signal(SIGQUIT, SIG_IGN);
X	hstat = signal(SIGHUP, SIG_IGN);
X
X	while ((r = wait(&status)) != popen_pid[f] && r != -1)
X		;
X
X	if (r == -1)
X		status = -1;
X
X	signal(SIGINT, istat);
X	signal(SIGQUIT, qstat);
X	signal(SIGHUP, hstat);
X	return(status);
X}
SHAR_EOF
if test 2683 -ne "`wc -c < 'expand.c'`"
then
	echo shar: "error transmitting 'expand.c'" '(should have been 2683 characters)'
fi
fi
echo shar: "extracting 'getcwd.c'" '(387 characters)'
if test -f 'getcwd.c'
then
	echo shar: "will not over-write existing file 'getcwd.c'"
else
sed 's/^X//' << \SHAR_EOF > 'getcwd.c'
X/*
X * Can you believe it???  Masscomps don't have a function to return the
X * current working directory while in the AT&T universe!
X */
X
X#include <stdio.h>
X
Xchar *
Xgetcwd(buf, size)
Xchar *buf;
Xint size;
X{
X	FILE *pfp, *popen();
X
X	if (!(pfp = popen("pwd", "r")))
X		return(".");
X
X	fgets(buf, size, pfp);
X	pclose(pfp);
X					/* zap the new line */
X	buf[strlen(buf)-1] = NULL;
X	return(buf);
X}
SHAR_EOF
if test 387 -ne "`wc -c < 'getcwd.c'`"
then
	echo shar: "error transmitting 'getcwd.c'" '(should have been 387 characters)'
fi
fi
echo shar: "extracting 'getopt.c'" '(1034 characters)'
if test -f 'getopt.c'
then
	echo shar: "will not over-write existing file 'getopt.c'"
else
sed 's/^X//' << \SHAR_EOF > 'getopt.c'
X/*
X * Parse the command line and return option flags and arguments
X */
X
X#include <stdio.h>
X
Xint optind = 1;
Xchar *optarg;
X
Xint
Xgetopt(argc, argv, opts)
Xint argc;
Xchar *argv[];
Xchar *opts;
X{
X	static int sp = 1;
X	int c, strcmp();
X	char *cp, *strchr();
X
X	if (sp == 1) {
X		if (optind >= argc || argv[optind][0] != '-' || argv[optind][1] == '\0')
X			return(EOF);
X		else if (strcmp(argv[optind], "--") == NULL) {
X			optind++;
X			return(EOF);
X		}
X	}
X	c = argv[optind][sp];
X	if (c == ':' || (cp=strchr(opts, c)) == NULL) {
X		fprintf(stderr, "%s: illegal option '%c'\n", argv[0], c);
X		if (argv[optind][++sp] == '\0') {
X			optind++;
X			sp = 1;
X		}
X		return('?');
X	}
X	if (*++cp == ':') {
X		if (argv[optind][sp+1] != '\0')
X			optarg = &argv[optind++][sp+1];
X		else if (++optind >= argc) {
X			fprintf(stderr, "%s: option '%c' requires an argument\n", argv[0], c);
X			sp = 1;
X			return('?');
X		} else
X			optarg = argv[optind++];
X		sp = 1;
X	} else {
X		if (argv[optind][++sp] == '\0') {
X			sp = 1;
X			optind++;
X		}
X		optarg = NULL;
X	}
X	return(c);
X}
SHAR_EOF
if test 1034 -ne "`wc -c < 'getopt.c'`"
then
	echo shar: "error transmitting 'getopt.c'" '(should have been 1034 characters)'
fi
fi
echo shar: "extracting 'help.c'" '(1802 characters)'
if test -f 'help.c'
then
	echo shar: "will not over-write existing file 'help.c'"
else
sed 's/^X//' << \SHAR_EOF > 'help.c'
X/*
X * Display the help screen.  Press any key to continue.  If the ascii_hot
X * string is more than 4 characters wide, this screen will look silly.
X * Maybe one day, this will also contain page-full descriptions of each
X * command.
X */
X
X#include <stdio.h>
X#include <curses.h>
X#include "config.h"
X#include "misc.h"
X
Xvoid
Xhelp_screen(hot)
Xchar *hot;
X{
X	extern int fd;
X	WINDOW *h_win, *newwin();
X
X	h_win = newwin(17, 80, 0, 0);
X
X	mvwattrstr(h_win, 1, 29, A_BOLD, "P C O M M       H E L P\n");
X	horizontal(h_win, 2, 0, 80);
X	mvwattrstr(h_win, 4, 0, A_BOLD, "       Major Functions          Utility Functions         File Functions\n\n");
X	mvwprintw(h_win,  6,  2, "Dialing Directory.%4.4s-D  Program Info ....%4.4s-I  Send Files ....%4.4s-<up>", hot, hot, hot);
X	mvwprintw(h_win,  7,  2, "Auto Redial ......%4.4s-R  Setup Screen ....%4.4s-S  Receive Files .%4.4s-<down>", hot, hot, hot);
X	mvwprintw(h_win,  8,  2, "Keyboard Macros ..%4.4s-M  Change Directory.%4.4s-B  Pass Thru Mode.%4.4s-T", hot, hot, hot);
X	mvwprintw(h_win,  9,  2, "Line Settings ....%4.4s-P  Clear Screen ....%4.4s-C  Directory .....%4.4s-F", hot, hot, hot);
X	mvwprintw(h_win, 10,  2, "Exit Pcomm .......%4.4s-X  Toggle Duplex ...%4.4s-E  Screen Dump ...%4.4s-G", hot, hot, hot);
X	mvwprintw(h_win, 11,  2, "Unix Gateway .....%4.4s-4  Hang Up Phone ...%4.4s-H  Start Data Log.%4.4s-1", hot, hot, hot);
X	mvwprintw(h_win, 12, 28, "Printer On/Off ..%4.4s-L  Toggle Log ....%4.4s-2", hot, hot);
X	mvwprintw(h_win, 13, 28, "Toggle CR-CR/LF .%4.4s-3", hot);
X	mvwprintw(h_win, 14, 28, "Break Key .......%4.4s-7", hot);
X
X	box(h_win, VERT, HORZ);
X	mvwaddstr(h_win, 16, 26, " Press any key to continue ");
X	wmove(h_win, 16, 79);
X	wrefresh(h_win);
X
X	wgetch(h_win);
X	if (fd == -1) {
X		werase(h_win);
X		wrefresh(h_win);
X	}
X	delwin(h_win);
X	return;
X}
SHAR_EOF
if test 1802 -ne "`wc -c < 'help.c'`"
then
	echo shar: "error transmitting 'help.c'" '(should have been 1802 characters)'
fi
fi
echo shar: "extracting 'info.c'" '(1532 characters)'
if test -f 'info.c'
then
	echo shar: "will not over-write existing file 'info.c'"
else
sed 's/^X//' << \SHAR_EOF > 'info.c'
X/*
X * Display the initial welcome screen (to include all of the proper
X * acknowledgements).  Press any key to continue.
X */
X
X#define VERSION "1.1"
X#define DATE	"21 Aug 88"
X
X#include <stdio.h>
X#include <curses.h>
X
Xvoid
Xinfo(delay)
Xint delay;
X{
X	extern int fd;
X	WINDOW *w_win, *newwin();
X	char buf[80];
X					/* display the welcome screen */
X	w_win = newwin(23, 80, 0, 0);
X	mvwaddstr(w_win, 3, 18, "PPPPPP    CCCC    OOOO    MM   MM   MM   MM");
X	mvwaddstr(w_win, 4, 18, "P    P   C       O    O   M M M M   M M M M");
X	mvwaddstr(w_win, 5, 18, "PPPPPP   C       O    O   M  M  M   M  M  M");
X	mvwaddstr(w_win, 6, 18, "P        C       O    O   M     M   M     M");
X	mvwaddstr(w_win, 7, 18, "P         CCCC    OOOO    M     M   M     M");
X
X	sprintf(buf, ">>> Pcomm Version %s <<<", VERSION);
X	mvwaddstr(w_win, 10, (80-strlen(buf))/2, buf);
X	sprintf(buf, "Release date: %s", DATE);
X	mvwaddstr(w_win, 11, (80-strlen(buf))/2, buf);
X
X	mvwaddstr(w_win, 13, 8, "Pcomm is a public domain telecommunication program for Unix that");
X	mvwaddstr(w_win, 14, 8, "is designed to operate similar to the MSDOS program, ProComm.");
X	mvwaddstr(w_win, 15, 8, "ProComm (TM) is copyrighted by Datastorm Technologies, Inc.");
X	mvwaddstr(w_win, 19, 45, "Emmet P. Gray");
X	mvwaddstr(w_win, 20, 45, "...!uunet!uiucuxc!fthood!egray");
X	wmove(w_win, 22, 79);
X	wrefresh(w_win);
X					/* Delay so you can read the herald */
X	if (delay)
X		wait_key(w_win, 5);
X	else
X		wgetch(w_win);
X
X	if (fd == -1) {
X		werase(w_win);
X		wrefresh(w_win);
X	}
X	delwin(w_win);
X	return;
X}
SHAR_EOF
if test 1532 -ne "`wc -c < 'info.c'`"
then
	echo shar: "error transmitting 'info.c'" '(should have been 1532 characters)'
fi
fi
echo shar: "extracting 'init.c'" '(2944 characters)'
if test -f 'init.c'
then
	echo shar: "will not over-write existing file 'init.c'"
else
sed 's/^X//' << \SHAR_EOF > 'init.c'
X/*
X * Display the welcome screen and find the Pcomm support files.  Returns a
X * pointer to the STATUS structure.  All errors are fatal.
X */
X
X#include <stdio.h>
X#include <curses.h>
X#include "config.h"
X#ifdef SHAREDMEM
X#include <sys/types.h>
X#include <sys/ipc.h>
X#include <sys/shm.h>
X#endif /* SHAREDMEM */
X#include "misc.h"
X#include "status.h"
X
Xstruct STATUS *
Xinit(short_cut)
Xchar *short_cut;
X{
X	char *mktemp(), *strcpy();
X	struct STATUS *s_ptr;
X	void info();
X#ifdef SHAREDMEM
X	int i, j, mode;
X	extern int shm_id;
X	char *shmat();
X	void exit();
X
X	/*
X	 * Since the "pcomm_input" program does not run set-user/group-id
X	 * the mode must be set so the effective ID can read/write to the
X	 * shared memory segment.  Kinda strange... real ID's aren't used.
X	 */
X#ifdef SETUGID
X	mode = 0666;
X#else /* SETUGID */
X	mode = 0600;
X#endif /* SETUGID */
X					/* create a shared memory segment */
X	shm_id = shmget(IPC_PRIVATE, sizeof (struct STATUS),  mode|IPC_CREAT|IPC_EXCL|IPC_NOWAIT);
X	if (shm_id < 0) {
X		endwin();
X		perror("shmget");
X		exit(1);
X	}
X	s_ptr = (struct STATUS *) shmat(shm_id, (char *) 0, 0);
X	if ((int) s_ptr == -1) {
X		endwin();
X		perror("shmat");
X		exit(1);
X	}
X#else /* SHAREDMEM */
X	static struct STATUS s;
X	s_ptr = &s;
X#endif /* SHAREDMEM */
X					/* some defaults */
X	s_ptr->fd = -1;
X	s_ptr->add_lf = 0;
X	s_ptr->log = 0;
X	s_ptr->print = 0;
X	strcpy(s_ptr->log_path, "NOT_DEFINED");
X#ifdef SHAREDMEM
X	s_ptr->clr = 0;
X	s_ptr->row = 0;
X	s_ptr->col = 0;
X	for (i=0; i<LINES; i++) {
X		for (j=0; j<COLS; j++)
X			s_ptr->vs[i][j] = ' ';
X		s_ptr->vs[i][COLS] = NULL;
X	}
X#else /* SHAREDMEM */
X	strcpy(s_ptr->vs_path, mktemp("/tmp/pcommXXXXXX"));
X#endif /* SHAREDMEM */
X					/* display herald if no short-cut */
X	if (short_cut == NULL)
X		info(1);
X
X	erase();
X	refresh();
X	return(s_ptr);
X}
X
X/*
X * Search the extra directory (supplied on the command line), then the
X * directory in the PCOMM environmental variable, then the current working
X * directory, and lastly, the default directory.
X */
X
Xchar *
Xfindfile(extra, name)
Xchar *extra, *name;
X{
X	int i;
X	char *pcomm, *getenv(), *path, pbuf[200], *getcwd(), *strdup();
X	char temp[200];
X
X					/* see if PCOMM variable is set */
X	pcomm = getenv("PCOMM");
X	if (pcomm == NULL || *pcomm == NULL)
X		pcomm = NULL;
X	else {
X					/* zap the trailing separator */
X		if (pcomm[strlen(pcomm)-1] == '/')
X			pcomm[strlen(pcomm)-1] = NULL;
X	}
X
X	for (i=0; i<4; i++) {
X					/* directory search order */
X		switch (i) {
X			case 0:		/* extra directory from command line */
X				path = extra;
X				break;
X			case 1:		/* PCOMM environmental variable */
X				path = pcomm;
X				break;
X			case 2:		/* current working directory */
X				path = getcwd(pbuf, 200);
X				break;
X			case 3:		/* Pcomm's default directory */
X				path = DEFAULT_DIR;
X				break;
X		}
X		if (path == NULL)
X			continue;
X
X		sprintf(temp, "%s/%s", path, name);
X					/* read permission checked */
X		if (!access(temp, 4))
X			return(strdup(temp));
X	}
X	return(NULL);
X}
SHAR_EOF
if test 2944 -ne "`wc -c < 'init.c'`"
then
	echo shar: "error transmitting 'init.c'" '(should have been 2944 characters)'
fi
fi
echo shar: "extracting 'input.c'" '(10147 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.  This program runs as a child process to the
X * Pcomm program.
X */
X
X#define CLIST 64
X
X#include <stdio.h>
X#include <signal.h>
X#include <setjmp.h>
X#include "config.h"
X#ifdef SHAREDMEM
X#include <sys/types.h>
X#include <sys/ipc.h>
X#include <sys/shm.h>
X#endif /* SHAREDMEM */
X#define MAIN
X#include "misc.h"
X#include "status.h"
X#include "vcs.h"
X
Xjmp_buf i_jmp;
Xint vcs_param[NUM_VCS][5];		/* positional parameters */
Xint vcs_opt[NUM_VCS][10];		/* options unique to each vcs */
Xint vcs_codes[NUM_VCS][VCS_SIZE];	/* the vcs codes */
Xint vcs_leadin[NUM_VCS];		/* unique list of lead-in characters */
Xint num_leadin;				/* length of lead-in list */
Xint hold, max_row, max_col, skip_row;
XFILE *logfp, *lprfp;
Xstruct STATUS *status;
X
X#ifdef SHAREDMEM
X#define VROW	status->row
X#define VCOL	status->col
X#define VS	status->vs
X#else /* SHAREDMEM */
Xint VROW, VCOL;
Xchar VS[MAX_ROW][MAX_COL+2];
Xstruct STATUS s;
X#endif /* SHAREDMEM */
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 */
X
Xmain(argc, argv)
Xint argc;
Xchar *argv[];
X{
X	FILE *popen();
X	int got_sig();
X	char c, *strcpy();
X	void _exit(), exit(), vcs_table();
X#ifdef SHAREDMEM
X	int shm_id;
X	char *shmat();
X#endif /* SHAREDMEM */
X					/* set the trap for the signals */
X	signal(SIGALRM, SIG_IGN);
X	signal(SIGHUP,  SIG_IGN);
X	signal(SIGQUIT, SIG_IGN);
X	signal(SIGUSR1, got_sig);
X	signal(SIGUSR2, got_sig);
X	signal(SIGINT,  got_sig);
X	signal(SIGTERM, got_sig);
X					/* unbuffered output */
X	setbuf(stdout, (char *) NULL);
X					/* for the curious... */
X	if (argc == 1) {
X		fprintf(stderr, "This is the input routine for the Pcomm program\n");
X		fprintf(stderr, "It is not designed to be run as a separate program\n");
X		exit(1);
X	}
X#ifdef SHAREDMEM
X	shm_id = atoi(argv[1]);
X	status = (struct STATUS *) shmat(shm_id, (char *) 0, 0);
X	if ((int) status == -1) {
X		perror("shmat");
X		_exit(1);
X	}
X#else /* SHAREDMEM */
X	status = &s;
X#endif /* SHAREDMEM */
X					/* load the VCS table */
X	vcs_table();
X	if (max_row > MAX_ROW)
X		max_row = MAX_ROW;
X	if (max_col > MAX_COL)
X		max_col = MAX_COL;
X					/* parse the command line */
X#ifndef SHAREDMEM
X	status->fd = atoi(argv[1]);
X	status->add_lf = atoi(argv[2]);
X	status->log = atoi(argv[3]);
X	status->print = atoi(argv[4]);
X	strcpy(status->log_path, argv[5]);
X	strcpy(status->vs_path, argv[6]);
X#endif /* SHAREDMEM */
X
X	skip_row = 0;
X#ifdef SHAREDMEM
X	if (status->clr)
X		skip_row = 1;
X#else /* SHAREDMEM */
X					/* read previous screen */
X	if (!access(status->vs_path, 0))
X		read_vs();
X	else
X		skip_row = 1;
X#endif /* SHAREDMEM */
X
X	hold = 0;
X					/* start up file pointers */
X	lprfp = (FILE *) NULL;
X	logfp = (FILE *) NULL;
X
X	switch (setjmp(i_jmp)) {
X		case 0:			/* no signal */
X			break;
X		case 1:			/* toggle the data logging */
X			status->log = status->log ? 0 : 1;
X			break;
X		case 2:			/* toggle the printer */
X			status->print = status->print ? 0 : 1;
X			break;
X		case 3:			/* suspend the input */
X			hold = hold ? 0 : 1;
X#ifndef SHAREDMEM
X			if (hold)
X				write_vs();
X#endif /* SHAREDMEM */
X			break;
X		case 4:			/* clean up and go home */
X			if (status->log)
X				fclose(logfp);
X			if (status->print) {
X				putc('\f', lprfp);
X				pclose(lprfp);
X			}
X#ifdef SHAREDMEM
X					/* detach shared memory */
X			shmdt((char *) status);
X#endif /* SHAREDMEM */
X			_exit(0);
X			break;
X	}
X					/* any signal will awaken pause() */
X	if (hold)
X		pause();
X					/* open or close the printer */
X	if (status->print && lprfp == NULL)
X		lprfp = popen(LPR, "w");
X
X	if (!status->print && lprfp != NULL) {
X		putc('\f', lprfp);
X		pclose(lprfp);
X		lprfp = (FILE *) NULL;
X	}
X					/* open or close the log file */
X	if (status->log && logfp == NULL) {
X		if (strcmp(status->log_path, "NOT_DEFINED")) {
X			if (!(logfp = fopen(status->log_path, "a")))
X				status->log = 0;
X		}
X		else
X			status->log = 0;
X	}
X	if (!status->log && logfp != NULL) {
X		fclose(logfp);
X		logfp = (FILE *) NULL;
X	}
X
X#ifdef SHAREDMEM
X	if (status->clr) {
X		status->clr = 0;
X		vs_clear();
X	}
X#else /* SHAREDMEM */
X					/* clear if vs_path doesn't exist */
X	if (access(status->vs_path, 0))
X		vs_clear();
X#endif /* SHAREDMEM */
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		VROW = 1;
X	}
X
X	while (1) {
X		if ((int) (c = readbyte()) <= 0)
X			continue;
X					/* send to logfile */
X		if (status->log) {
X			if (c == '\r' && status->add_lf)
X				putc('\n', logfp);
X					/* no carriage returns in logfile */
X			if (c != '\r')
X				putc(c, logfp);
X		}
X					/* send to printer too? */
X		if (status->print)
X			putc(c, lprfp);
X
X					/* put a char in virtual screen */
X		vs_putchar(c);
X
X		putchar(c);
X					/* add LF to CR? */
X		if (c == '\r' && status->add_lf)
X			putchar('\n');
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	switch (sig) {
X		case SIGUSR1:
X			signal(SIGUSR1, got_sig);
X			longjmp(i_jmp, 1);
X		case SIGUSR2:
X			signal(SIGUSR2, got_sig);
X			longjmp(i_jmp, 2);
X		case SIGINT:
X			signal(SIGINT, got_sig);
X			longjmp(i_jmp, 3);
X		case SIGTERM:
X			signal(SIGTERM, got_sig);
X			longjmp(i_jmp, 4);
X	}
X}
X
X/*
X * Put a character in the virtual screen.  This routine saves incoming
X * characters in a two dimensional buffer designed to mimic the real
X * screen.
X */
X
Xint
Xvs_putchar(c)
Xchar c;
X{
X	register int j, i;
X	int tab_stop;
X
X	switch (vcs_filter(c)) {
X		case MAYBE:		/* wait and see... */
X			break;
X		case 256+HOME:		/* home virtual screen "cursor" */
X			VROW = 0;
X			VCOL = 0;
X			break;
X		case 256+CLR_EOL:	/* clear to end of line */
X			for (i=VCOL; i<max_col; i++)
X				VS[VROW][i] = ' ';
X			break;
X		case 256+CLR_EOS:	/* clear to end of screen */
X			for (j=VCOL; j<max_col; j++)
X				VS[VROW][j] = ' ';
X			for (i=VROW+1; i<max_row; i++) {
X				for (j=0; j<max_col; j++)
X					VS[i][j] = ' ';
X			}
X			break;
X		case 256+CLEAR:		/* clear all and home "cursor" */
X			for (i=0; i<max_row; i++) {
X				for (j=0; j<max_col; j++)
X					VS[i][j] = ' ';
X			}
X			VROW = 0;
X			VCOL = 0;
X			break;
X		case 256+MV_UP:		/* move "cursor" up */
X			VROW--;
X			if (VROW < 0)
X				VROW = 0;
X			break;
X		case 256+MV_DOWN:	/* move "cursor" down */
X			VROW++;
X			if (VROW >= max_row)
X				VROW = max_row -1;
X			break;
X		case 256+MV_RIGHT:	/* move "cursor" right */
X			VCOL++;
X			if (VCOL >= max_col)
X				VCOL = max_col -1;
X			break;
X		case 256+MV_LEFT:	/* move "cursor" left */
X		case BS:		/* non destructive back space */
X			VCOL--;
X			if (VCOL < 0)
X				VCOL = 0;
X			break;
X		case 256+MV_DIRECT:	/* direct cursor movement */
X			VROW = vcs_param[MV_DIRECT][0];
X			VCOL = vcs_param[MV_DIRECT][1];
X
X					/* if "add one" and "decimal" */
X			if (vcs_opt[MV_DIRECT][0] && vcs_opt[MV_DIRECT][1]) {
X				VROW--;
X				VCOL--;
X			}
X					/* if "character" */
X			if (vcs_opt[MV_DIRECT][2]) {
X					/* if "add offset" */
X				if (vcs_opt[MV_DIRECT][3]) {
X					VROW -= vcs_opt[MV_DIRECT][5];
X					VCOL -= vcs_opt[MV_DIRECT][5];
X				}
X					/* if "subtract offset" */
X				if (vcs_opt[MV_DIRECT][4]) {
X					VROW += vcs_opt[MV_DIRECT][5];
X					VCOL += vcs_opt[MV_DIRECT][5];
X				}
X				VROW--;
X				VCOL--;
X			}
X			break;
X		case '\t':		/* tab character */
X			tab_stop = VCOL + 8 - (VCOL % 8);
X					/* if wrap around */
X			if (tab_stop >= max_col) {
X					/* spaces up to eol */
X				for (; VCOL<max_col; VCOL++)
X					VS[VROW][VCOL] = ' ';
X				VROW++;
X				if (VROW >= max_row)
X					vs_scroll();
X
X					/* the remainder of the tab */
X				VCOL = tab_stop - max_col;
X			}
X			else {
X				for (; VCOL<tab_stop; VCOL++)
X					VS[VROW][VCOL] = ' ';
X			}
X			break;
X		case '\r':		/* carriage return */
X			VCOL = 0;
X			if (!status->add_lf)
X				break;
X			/* fall thru...*/
X		case '\n':		/* line feed */
X			VROW++;
X			if (VROW >= max_row)
X				vs_scroll();
X			break;
X		default:		/* a normal character */
X			VS[VROW][VCOL] = c;
X			VCOL++;
X					/* wrap around */
X			if (VCOL >= max_col) {
X				VCOL = 0;
X				VROW++;
X				if (VROW >= max_row)
X					vs_scroll();
X			}
X			break;
X	}
X	return(0);
X}
X
X#ifndef SHAREDMEM
X/*
X * Save the virtual screen to a file.
X */
X
Xint
Xwrite_vs()
X{
X	FILE *fp;
X	register int i;
X
X	if (!(fp = fopen(status->vs_path, "w")))
X		return(1);
X					/* current x y coordinates */
X	fprintf(fp, "%d,%d\n", VROW, VCOL);
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()
X{
X	FILE *fp;
X	register int i;
X	char buf[10];
X				/* in case the fopen fails... */
X	VROW = 0;
X	VCOL = 0;
X				/* not guaranteed to exist yet */
X	if (!(fp = fopen(status->vs_path, "r")))
X		return(1);
X				/* get the x, y coordinates */
X	fgets(buf, 10, fp);
X	scanf(buf, "%d,%d\n", VROW, VCOL);
X
X				/* read the file into the vs array */
X	for (i=0; i<max_row; i++) {
X		fgets(VS[i], MAX_COL+2, fp);
X		VS[i][max_col] = NULL;
X	}
X	fclose(fp);
X	return(0);
X}
X#endif /* SHAREDMEM */
X
X/*
X * If the user clears the screen with the ^A-C command, the input
X * has to be in sync.
X */
X
Xint
Xvs_clear()
X{
X	register int j, i;
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	VROW = 0;
X	VCOL = 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
Xvs_scroll()
X{
X	register int i;
X	char *strcpy();
X					/* move 'em up 1 line */
X	for (i=0; i<max_row-1; i++)
X		strcpy(VS[i], VS[i+1]);
X					/* clear the bottom line */
X	for (i=0; i<max_col; i++)
X		VS[max_row-1][i] = ' ';
X
X	VROW = max_row -1;
X	return(0);
X}
X
X/*
X * Do a buffered read from the serial port.
X */
X
Xint
Xreadbyte()
X{
X	static char buf[CLIST];
X	static char *bufp = buf;
X	static int n = 0;
X
X	if (n <= 0) {
X		if ((n = read(status->fd, buf, CLIST)) <= 0)
X			return(-1);
X		bufp = buf;
X	}
X	while (--n >= 0)
X		return(*bufp++ & 0xff);
X	return(-1);
X}
SHAR_EOF
if test 10147 -ne "`wc -c < 'input.c'`"
then
	echo shar: "error transmitting 'input.c'" '(should have been 10147 characters)'
fi
fi
echo shar: "extracting 'line_set.c'" '(1944 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
Xvoid
Xline_set()
X{
X	extern int fd;
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 (fd == -1)
X		return;
X					/* get the current settings */
X	ioctl(fd, TCGETA, &tbuf);
X					/* set some beginning values */
X	tbuf.c_cc[4] = 1;		/* VMIN */
X	tbuf.c_cc[5] = 0;		/* VTIME */
X	tbuf.c_oflag = 0;
X	tbuf.c_iflag = 0;
X	tbuf.c_cflag = (CREAD|HUPCL|CLOCAL);
X	tbuf.c_lflag = 0;
X
X	if (*param->flow == 'X')
X		tbuf.c_iflag |= IXON|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#ifdef B19200
X			tbuf.c_cflag |= B19200;
X#else /* B19200 */
X#ifdef EXTA
X			tbuf.c_cflag |= EXTA;
X#endif /* EXTA */
X#endif /* 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(fd, TCSETA, &tbuf);
X	ioctl(fd, TCFLSH, 2);
X	return;
X}
SHAR_EOF
if test 1944 -ne "`wc -c < 'line_set.c'`"
then
	echo shar: "error transmitting 'line_set.c'" '(should have been 1944 characters)'
fi
fi
echo shar: "extracting 'list_dir.c'" '(1508 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 "config.h"
X#include "misc.h"
X
Xvoid
Xlist_dir()
X{
X	extern int fd;
X	WINDOW *ls_win, *newwin();
X	FILE *pfp, *n_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, VERT, HORZ);
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) {
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 = n_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	touchwin(ls_win);
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) == ESC) {
X				oops++;
X				break;
X			}
X			werase(ls_win);
X			wrefresh(ls_win);
X		}
X	}
X	n_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 1508 -ne "`wc -c < 'list_dir.c'`"
then
	echo shar: "error transmitting 'list_dir.c'" '(should have been 1508 characters)'
fi
fi
echo shar: "extracting 'ls_menu.c'" '(4809 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 "config.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
Xls_menu()
X{
X	extern int fd;
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	horizontal(l_win, 2, 0, 47);
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, VERT, HORZ);
X
X	mvwaddstr(l_win, 19, 13, " 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 (up_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
Xstatic void
Xdisp_settings(win)
XWINDOW *win;
X{
X	extern int xmc;
X	char buf[40];
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 4809 -ne "`wc -c < 'ls_menu.c'`"
then
	echo shar: "error transmitting 'ls_menu.c'" '(should have been 4809 characters)'
fi
fi
exit 0
#	End of shell archive



More information about the Unix-pc.sources mailing list