minicom.c

小型通讯程序的C语言源程序的C语言源程序库

/*
 * This file is part of the Minicom Communications Program,
 * written by Miquel van Smoorenburg 1991/1992/1993.
 *
 * minicom.c - main program.
 */
#include <sys/types.h>
#if defined (_POSIX_SOURCE) || defined(_BSD43)
#  include <unistd.h>
#  include <stdlib.h>
#else
   char *getenv();
#endif
#undef NULL
#include <signal.h>
#include <fcntl.h>
#include <setjmp.h>
#include <sys/stat.h>
#include <string.h>
#include <stdio.h>
#include <pwd.h>
#include <ctype.h>

#include "window.h"
#include "keyboard.h"
#include "vt100.h"
#define EXTERN
#include "minicom.h"
#include "configsym.h"

#ifndef _NSIG
#  define _NSIG NSIG
#endif

#define RESET 1
#define NORESET 2

#ifdef _SVR2
extern struct passwd *getpwuid();
#endif

#ifdef DEBUG
/* Show signals when debug is on. */
static void signore(sig)
int sig;
{
  if (stdwin != NIL_WIN)
	werror("Got signal %d", sig);
  else
	printf("Got signal %d\r\n", sig);
}
#endif

/*
 * Sub - menu's.
 */

static char *c1[] = { "   Yes  ", "   No   ", CNULL };
static char *c2[] = { "  Close ", " Pause  ", "  Exit  ", CNULL };
static char *c3[] = { "  Close ", " Unpause", "  Exit  ", CNULL };
static char *c7[] = { "   Yes  ", "   No   ", CNULL };
static char *c8[] = { " vt100", " Minix", " Ansi", CNULL };

static void do_hang(askit)
int askit;
{
  int c = 0;
 
  if (askit) c = ask("Hang-up line?", c7);
  if (c == 0) hangup();
}

/*
 * We've got the hangup or term signal.
 */
static void hangsig(sig)
int sig;
{
#if DEBUG
  char txt[80];
#else
  char *txt = "\n"; /* "Thanks for using Minicom\n"; */
  		    /* Allright Will, this is probably overdone :-) */
#endif
  
  werror("Killed by signal %d !\n", sig);
  if (capfp != (FILE *)0) fclose(capfp);
  keyboard(KUNINSTALL, 0);
  hangup();
  modemreset();
  leave(txt);
}

/*
 * Jump to a shell
 */
static void shjump()
{
  char *sh;
  int pid;
  int status;
  int f;

  sh = getenv("SHELL");
  if (sh == CNULL) {
  	werror("SHELL variable not set");
  	return;
  }
  if ((pid = fork()) == -1) {
  	werror("Out of memory: could not fork()");
  	return;
  }
  if (pid != 0) wleave();
  if (pid == 0) {
	for(f = 1; f < _NSIG; f++) signal(f, SIG_DFL);
  	for(f = 3; f < 20; f++) close(f);
	setgid(real_gid);
  	setuid(real_uid);
  	execl(sh, sh, CNULL);
  	exit(1);
  }
  (void) m_wait(&status);
  wreturn();
}

#if HISTORY
/* Get a line from either window or scroll back buffer. */
static ELM *getline(w, no)
WIN *w;
int no;
{
  int i;

  if (no < us->histlines) {
	i = no + us->histline - 1;
	if (i >= us->histlines) i -= us->histlines;
	if (i < 0) i = us->histlines - 1;
	return(us->histbuf + (i * us->xs));
  }

  no -= us->histlines;
  if (no >= w->ys) no = w->ys - 1;
  return(w->map + (no * us->xs));
}

/* Redraw the window. */
static void drawhist(w, y, r)
WIN *w;
int y;
int r;
{
  int f;

  w->direct = 0;
  for(f = 0; f < w->ys; f++)
	wdrawelm(w, f, getline(w, y++));
  if (r) wredraw(w, 1);
  w->direct = 1;
}

/* Scroll back */
static void scrollback()
{
  int y;
  WIN *b_us, *b_st;
  int c;
  char hline[128];

  /* Find out how big a window we must open. */
  y = us->y2;
  if (st == (WIN *)0 || (st && tempst)) y--;

  /* Open a window. */ 
  b_us = wopen(0, 0, us->x2, y, 0, us->attr, COLFG(us->color),
		COLBG(us->color), 0, 0, 0);
  wcursor(b_us, CNONE);

  /* Open a help line window. */
  b_st = wopen(0, y+1, us->x2, y+1, 0, A_REVERSE, WHITE, BLACK, 0, 0, 0);
  b_st->doscroll = 0;
  b_st->wrap = 0;

  /* Make sure help line is as wide as window. */
  strcpy(hline, "   SCROLL MODE    U=up D=down F=page-forward B=page-backward ESC=exit                    ");
  if (b_st->xs < 127) hline[b_st->xs] = 0;
  wprintf(b_st, hline);
  wredraw(b_st, 1);
  wflush();

  /* And do the job. */
  y = us->histlines;

  drawhist(b_us, y, 0);

  while((c = getch()) != K_ESC) {
	switch(c) {
	  case 'u':
	  case K_UP:
		if (y <= 0) break;
		y--;
		wscroll(b_us, S_DOWN);
		wdrawelm(b_us, 0, getline(b_us, y));
		wflush();
		break;
	  case 'd':
	  case K_DN:
		if (y >= us->histlines) break;
		y++;
		wscroll(b_us, S_UP);
		wdrawelm(b_us, b_us->ys - 1, getline(b_us, y + b_us->ys - 1));
		wflush();
		break;
	  case 'b':
	  case K_PGUP:
		if (y <= 0) break;
		y -= b_us->ys;
		if (y < 0) y = 0;
		drawhist(b_us, y, 1);
		break;
	  case 'f':
	  case K_PGDN:
		if (y >= us->histlines) break;
		y += b_us->ys;
		if (y > us->histlines) y = us->histlines;
		drawhist(b_us, y, 1);
		break;
	}
  }
  /* Cleanup. */
  wclose(b_us, y == us->histlines ? 0 : 1);
  wclose(b_st, 1);
  wlocate(us, us->curx, us->cury);
  wflush();
}
#endif

#ifdef SIGWINCH
/* The window size has changed. Re-initialize. */
static void change_size(sig)
int sig;
{
  (void)sig;
  size_changed = 1;
  signal(SIGWINCH, change_size);
}
#endif

/*
 * Read a word from strings 's' and advance pointer.
 */
static char *getword(s)
char **s;
{
  char *begin;

  /* Skip space */
  while(**s == ' ' || **s == '\t') (*s)++;
  /* End of line? */
  if (**s == '\0' || **s == '\n') return((char *)0);
  
  begin = *s;
  /* Skip word */
  while(**s != ' ' && **s != '\t' && **s != '\n' && **s) (*s)++;
  /* End word with '\0' */
  if (**s) {
  	**s = 0;
  	(*s)++;
  }
  return(begin);
}

static char *bletch = 
  "Usage: minicom [-soml] [-c on|off] [-a on|off] [-t TERM] [configuration]\n";

static void usage(env_args, optind, mc)
int env_args, optind;
char *mc;
{
  if (env_args >= optind && mc)
  	fprintf(stderr, "Wrong option in environment MINICOM=%s\n", mc);
  fprintf(stderr, bletch);
  fprintf(stderr, "Type \"minicom -h\" for help.\n");
  exit(1);
}

/* Give some help information */
static void helpthem()
{
  char *mc = getenv("MINICOM");

  printf("\n%s", Version);
#ifdef __DATE__
  printf(" (compiled %s)", __DATE__);
#endif
  printf("\n\n%s\n", bletch);
  printf("  -s             : enter setup mode (only as root)\n");
  printf("  -o             : do not initialize modem & lockfiles at startup\n");
  printf("  -m             : use meta or alt key for commands\n");
  printf("  -l             : literal ; do not translate characters < 32 or > 127\n");
  printf("  -c [on | off]  : ANSI style color usage on or off\n");
  printf("  -a [on | off]  : use reverse or highlight attributes on or off\n");
  printf("  -t term        : override TERM environment variable\n");
  printf("  configuration  : configuration file to use\n\n");
  printf("These options can also be specified in the MINICOM environment variable.\n");
  printf("This variable is currently %s%s.\n", mc ? "set to " : "unset",
	mc ? mc : "");
  printf("\nThe LIBDIR to find the configuration files and the\n");
  printf("access file minicom.users is compiled as %s.\n\n", LIBDIR);
}

int main(argc, argv)
int argc;
char **argv;
{
  int c;			/* Command character */
  int quit = 0;			/* 'q' or 'x' pressed */
  char *s, *bufp;		/* Scratch pointers */
  int dosetup = 0, doinit = 1;	/* -o and -s options */
  char buf[80];			/* Keyboard input buffer */
  char capname[128];		/* Name of capture file */
  struct passwd *pwd;		/* To look up user name */
  int userok = 0;		/* Scratch variables */
  FILE *fp;			/* Scratch file pointer */
  char userfile[256];		/* Locate user file */
  char *use_port;		/* Name of initialization file */
  char *args[20];		/* New argv pointer */
  int argk = 1;			/* New argc */
  extern int getopt(), optind;
  extern char *optarg;		/* From getopt (3) package */
  char *mc;			/* For 'MINICOM' env. variable */
  int env_args;			/* Number of args in env. variable */

  /* Initialize global variables */
  portfd = -1;
  capfp = (FILE *)NULL;
  docap = 0;
  online = linewrap = -1;
  stdattr = A_NORMAL;
  us = NIL_WIN;
  addlf = 0;
  local_echo = 0;
  strcpy(capname, "minicom.cap");
  lockfile[0] = 0;
  tempst = 0;
  st = NIL_WIN;
  us = NIL_WIN;
  bogus_dcd = 0;
  usecolor = 0;
  literal = 0;
  useattr = 1;
  strcpy(termtype, getenv("TERM") ? getenv("TERM") : "dumb");
  stdattr = A_NORMAL;
  use_port = "dfl";
  alt_override = 0;
  scr_name[0] = 0;
  scr_user[0] = 0;
  scr_passwd[0] = 0;
  dial_name = (char *)NULL;
  dial_number = (char *)NULL;
  size_changed = 0;
  escape = 1;
#ifndef DEBUG
  real_uid = getuid();
  real_gid = getgid();
#else
  real_uid = 0;
  real_gid = 0;
#endif

  /* Before processing the options, first add options
   * from the environment variable 'MINICOM'.
   */
  args[0] = "minicom";
  if ((mc = getenv("MINICOM")) != CNULL) {
 	strncpy(buf, mc, 80);
 	bufp = buf;
 	buf[79] = 0;
 	while(isspace(*bufp)) bufp++;