xref: /freebsd/usr.sbin/ppp/chat.c (revision 63b7346316afa0c20b6cf22506bcc53abc9f08f8)

/*
 *	    Written by Toshiharu OHNO (tony-o@iij.ad.jp)
 *
 *   Copyright (C) 1993, Internet Initiative Japan, Inc. All rights reserverd.
 *
 *  Most of codes are derived from chat.c by Karl Fox (karl@MorningStar.Com).
 *
 *	Chat -- a program for automatic session establishment (i.e. dial
 *		the phone and log in).
 *
 *	This software is in the public domain.
 *
 *	Please send all bug reports, requests for information, etc. to:
 *
 *		Karl Fox <karl@MorningStar.Com>
 *		Morning Star Technologies, Inc.
 *		1760 Zollinger Road
 *		Columbus, OH  43221
 *		(614)451-1883
 *
 * $Id: chat.c,v 1.44 1998/01/21 02:15:13 brian Exp $
 *
 *  TODO:
 *	o Support more UUCP compatible control sequences.
 *	o Dialing shoud not block monitor process.
 *	o Reading modem by select should be unified into main.c
 */
#include <sys/param.h>
#include <netinet/in.h>

#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <setjmp.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <termios.h>
#include <unistd.h>

#include "command.h"
#include "mbuf.h"
#include "log.h"
#include "defs.h"
#include "timer.h"
#include "loadalias.h"
#include "vars.h"
#include "chat.h"
#include "modem.h"
#include "physical.h"

#ifndef isblank
#define	isblank(c)	((c) == '\t' || (c) == ' ')
#endif


#define	IBSIZE LINE_LEN

static int TimeoutSec;
static int abort_next, timeout_next;
static int numaborts;
static char *AbortStrings[50];
static char inbuff[IBSIZE * 2 + 1];
static jmp_buf ChatEnv;

#define	MATCH	1
#define	NOMATCH	0
#define	ABORT	-1

static char *
findblank(char *p, int instring)
{
  if (instring) {
    while (*p) {
      if (*p == '\\') {
	strcpy(p, p + 1);
	if (!*p)
	  break;
      } else if (*p == '"')
	return (p);
      p++;
    }
  } else {
    while (*p) {
      if (isblank(*p))
	return (p);
      p++;
    }
  }
  return p;
}

int
MakeArgs(char *script, char **pvect, int maxargs)
{
  int nargs, nb;
  int instring;

  nargs = 0;
  while (*script) {
    nb = strspn(script, " \t");
    script += nb;
    if (*script) {
      if (*script == '"') {
	instring = 1;
	script++;
	if (*script == '\0')
	  break;		/* Shouldn't return here. Need to null
				 * terminate below */
      } else
	instring = 0;
      if (nargs >= maxargs - 1)
	break;
      *pvect++ = script;
      nargs++;
      script = findblank(script, instring);
      if (*script)
	*script++ = '\0';
    }
  }
  *pvect = NULL;
  return nargs;
}

/*
 *  \c	don't add a cr
 *  \d  Sleep a little (delay 2 seconds
 *  \n  Line feed character
 *  \P  Auth Key password
 *  \p  pause 0.25 sec
 *  \r	Carrige return character
 *  \s  Space character
 *  \T  Telephone number(s) (defined via `set phone')
 *  \t  Tab character
 *  \U  Auth User
 */
char *
ExpandString(const char *str, char *result, int reslen, int sendmode)
{
  int addcr = 0;
  char *phone;

  result[--reslen] = '\0';
  if (sendmode)
    addcr = 1;
  while (*str && reslen > 0) {
    switch (*str) {
    case '\\':
      str++;
      switch (*str) {
      case 'c':
	if (sendmode)
	  addcr = 0;
	break;
      case 'd':		/* Delay 2 seconds */
	nointr_sleep(2);
	break;
      case 'p':
	nointr_usleep(250000);
	break;			/* Pause 0.25 sec */
      case 'n':
	*result++ = '\n';
	reslen--;
	break;
      case 'r':
	*result++ = '\r';
	reslen--;
	break;
      case 's':
	*result++ = ' ';
	reslen--;
	break;
      case 't':
	*result++ = '\t';
	reslen--;
	break;
      case 'P':
	strncpy(result, VarAuthKey, reslen);
	reslen -= strlen(result);
	result += strlen(result);
	break;
      case 'T':
	if (VarAltPhone == NULL) {
	  if (VarNextPhone == NULL) {
	    strncpy(VarPhoneCopy, VarPhoneList, sizeof VarPhoneCopy - 1);
	    VarPhoneCopy[sizeof VarPhoneCopy - 1] = '\0';
	    VarNextPhone = VarPhoneCopy;
	  }
	  VarAltPhone = strsep(&VarNextPhone, ":");
	}
	phone = strsep(&VarAltPhone, "|");
	strncpy(result, phone, reslen);
	reslen -= strlen(result);
	result += strlen(result);
	if (VarTerm)
	  fprintf(VarTerm, "Phone: %s\n", phone);
	LogPrintf(LogPHASE, "Phone: %s\n", phone);
	break;
      case 'U':
	strncpy(result, VarAuthName, reslen);
	reslen -= strlen(result);
	result += strlen(result);
	break;
      default:
	reslen--;
	*result++ = *str;
	break;
      }
      if (*str)
	str++;
      break;
    case '^':
      str++;
      if (*str) {
	*result++ = *str++ & 0x1f;
	reslen--;
      }
      break;
    default:
      *result++ = *str++;
      reslen--;
      break;
    }
  }
  if (--reslen > 0) {
    if (addcr)
      *result++ = '\r';
  }
  if (--reslen > 0)
    *result++ = '\0';
  return (result);
}

#define MAXLOGBUFF LINE_LEN
static char logbuff[MAXLOGBUFF];
static int loglen = 0;

static void
clear_log(void)
{
  memset(logbuff, 0, MAXLOGBUFF);
  loglen = 0;
}

static void
flush_log(void)
{
  if (LogIsKept(LogCONNECT))
    LogPrintf(LogCONNECT, "%s\n", logbuff);
  else if (LogIsKept(LogCARRIER) && strstr(logbuff, "CARRIER"))
    LogPrintf(LogCARRIER, "%s\n", logbuff);

  clear_log();
}

static void
connect_log(const char *str, int single_p)
{
  int space = MAXLOGBUFF - loglen - 1;

  while (space--) {
    if (*str == '\n') {
      flush_log();
    } else {
      logbuff[loglen++] = *str;
    }
    if (single_p || !*++str)
      break;
  }
  if (!space)
    flush_log();
}

static void
ExecStr(struct physical *physical, char *command, char *out, int olen)
{
  pid_t pid;
  int fids[2];
  char *vector[MAXARGS], *startout, *endout;
  int stat, nb;

  LogPrintf(LogCHAT, "Exec: %s\n", command);
  MakeArgs(command, vector, VECSIZE(vector));

  if (pipe(fids) < 0) {
    LogPrintf(LogCHAT, "Unable to create pipe in ExecStr: %s\n",
	      strerror(errno));
    longjmp(ChatEnv, 2);
  }
  if ((pid = fork()) == 0) {
    TermTimerService();
    signal(SIGINT, SIG_DFL);
    signal(SIGQUIT, SIG_DFL);
    signal(SIGTERM, SIG_DFL);
    signal(SIGHUP, SIG_DFL);
    signal(SIGALRM, SIG_DFL);
	/* XXX-ML This looks like it might need more encapsulation. */
    if (Physical_GetFD(physical) == 2) {
	   Physical_DupAndClose(physical);
    }
    close(fids[0]);
    dup2(fids[1], 2);
    close(fids[1]);
    dup2(Physical_GetFD(physical), 0);
    dup2(Physical_GetFD(physical), 1);
    if ((nb = open("/dev/tty", O_RDWR)) > 3) {
      dup2(nb, 3);
      close(nb);
    }
    setuid(geteuid());
    execvp(vector[0], vector);
    fprintf(stderr, "execvp failed: %s: %s\n", vector[0], strerror(errno));
    exit(127);
  } else {
    char *name = strdup(vector[0]);

    close(fids[1]);
    endout = out + olen - 1;
    startout = out;
    while (out < endout) {
      nb = read(fids[0], out, 1);
      if (nb <= 0)
	break;
      out++;
    }
    *out = '\0';
    close(fids[0]);
    close(fids[1]);
    waitpid(pid, &stat, WNOHANG);
    if (WIFSIGNALED(stat)) {
      LogPrintf(LogWARN, "%s: signal %d\n", name, WTERMSIG(stat));
      free(name);
      longjmp(ChatEnv, 3);
    } else if (WIFEXITED(stat)) {
      switch (WEXITSTATUS(stat)) {
        case 0:
          free(name);
          break;
        case 127:
          LogPrintf(LogWARN, "%s: %s\n", name, startout);
          free(name);
          longjmp(ChatEnv, 4);
          break;
        default:
          LogPrintf(LogWARN, "%s: exit %d\n", name, WEXITSTATUS(stat));
          free(name);
          longjmp(ChatEnv, 5);
          break;
      }
    } else {
      LogPrintf(LogWARN, "%s: Unexpected exit result\n", name);
      free(name);
      longjmp(ChatEnv, 6);
    }
  }
}

static int
WaitforString(struct physical *physical, const char *estr)
{
  struct timeval timeout;
  char *s, *str, ch;
  char *inp;
  fd_set rfds;
  int i, nfds, nb;
  char buff[IBSIZE];
#ifdef SIGALRM
  int omask;

  omask = sigblock(sigmask(SIGALRM));
#endif
  clear_log();
  if (*estr == '!') {
    ExpandString(estr + 1, buff, sizeof buff, 0);
    ExecStr(physical, buff, buff, sizeof buff);
  } else {
    ExpandString(estr, buff, sizeof buff, 0);
  }
  if (LogIsKept(LogCHAT)) {
    s = buff + strlen(buff) - 1;
    while (s >= buff && *s == '\n')
      s--;
    if (!strcmp(estr, buff))
      LogPrintf(LogCHAT, "Wait for (%d): %.*s\n",
                TimeoutSec, s - buff + 1, buff);
    else
      LogPrintf(LogCHAT, "Wait for (%d): %s --> %.*s\n",
                TimeoutSec, estr, s - buff + 1, buff);
  }

  if (buff[0] == '\0')
    return (MATCH);

  str = buff;
  inp = inbuff;

  if (strlen(str) >= IBSIZE) {
    str[IBSIZE - 1] = 0;
    LogPrintf(LogCHAT, "Truncating String to %d character: %s\n", IBSIZE, str);
  }
  /* XXX-ML - this look REALLY fishy.  */
  nfds = Physical_GetFD(physical) + 1;
  s = str;
  for (;;) {
    FD_ZERO(&rfds);
    FD_SET(Physical_GetFD(physical), &rfds);

    /*
     * Because it is not clear whether select() modifies timeout value, it is
     * better to initialize timeout values everytime.
     */
    timeout.tv_sec = TimeoutSec;
    timeout.tv_usec = 0;
    i = select(nfds, &rfds, NULL, NULL, &timeout);
#ifdef notdef
    TimerService();
#endif
    if (i < 0) {
#ifdef SIGALRM
      if (errno == EINTR)
	continue;
      sigsetmask(omask);
#endif
      LogPrintf(LogERROR, "WaitForString: select(): %s\n", strerror(errno));
      *inp = 0;
      return (NOMATCH);
    } else if (i == 0) {	/* Timeout reached! */
      *inp = 0;
      if (inp != inbuff)
	LogPrintf(LogCHAT, "Got: %s\n", inbuff);
      LogPrintf(LogCHAT, "Can't get (%d).\n", timeout.tv_sec);
#ifdef SIGALRM
      sigsetmask(omask);
#endif
      return (NOMATCH);
    }
    if (Physical_FD_ISSET(physical, &rfds)) {	/* got something */
      if (Physical_IsSync(physical)) {
	int length;

	if ((length = strlen(inbuff)) > IBSIZE) {
	  /* shuffle down next part */
	  memcpy(inbuff, &(inbuff[IBSIZE]), IBSIZE + 1);
	  length = strlen(inbuff);
	}
	if (length + IBSIZE > sizeof(inbuff))
	    abort();		/* Bug & security problem */
	nb = Physical_Read(physical, &(inbuff[length]), IBSIZE);
	inbuff[nb + length] = 0;
	connect_log(inbuff, 0);
	if (strstr(inbuff, str)) {
#ifdef SIGALRM
	  sigsetmask(omask);
#endif
	  flush_log();
	  return (MATCH);
	}
	for (i = 0; i < numaborts; i++) {
	  if (strstr(inbuff, AbortStrings[i])) {
	    LogPrintf(LogCHAT, "Abort: %s\n", AbortStrings[i]);
#ifdef SIGALRM
	    sigsetmask(omask);
#endif
	    flush_log();
	    return (ABORT);
	  }
	}
      } else {
	if (Physical_Read(physical, &ch, 1) < 0) {
	  LogPrintf(LogERROR, "read error: %s\n", strerror(errno));
	  *inp = '\0';
	  return (NOMATCH);
	}
	connect_log(&ch, 1);
	*inp++ = ch;
	if (ch == *s) {
	  s++;
	  if (*s == '\0') {
#ifdef SIGALRM
	    sigsetmask(omask);
#endif
	    *inp = 0;
	    flush_log();
	    return (MATCH);
	  }
	} else
	  s = str;
	if (inp == inbuff + IBSIZE) {
	  memcpy(inbuff, inp - 100, 100);
	  inp = inbuff + 100;
	}
	if (s == str) {
	  for (i = 0; i < numaborts; i++) {	/* Look for Abort strings */
	    int len;
	    char *s1;

	    s1 = AbortStrings[i];
	    len = strlen(s1);
	    if ((len <= inp - inbuff) && (strncmp(inp - len, s1, len) == 0)) {
	      LogPrintf(LogCHAT, "Abort: %s\n", s1);
	      *inp = 0;
#ifdef SIGALRM
	      sigsetmask(omask);
#endif
	      flush_log();
	      return (ABORT);
	    }
	  }
	}
      }
    }
  }
}

static void
SendString(struct physical *physical, const char *str)
{
  char *cp;
  int on;
  char buff[LINE_LEN];

  if (abort_next) {
    abort_next = 0;
    ExpandString(str, buff, sizeof buff, 0);
    AbortStrings[numaborts++] = strdup(buff);
  } else if (timeout_next) {
    timeout_next = 0;
    TimeoutSec = atoi(str);
    if (TimeoutSec <= 0)
      TimeoutSec = 30;
  } else {
    if (*str == '!') {
      ExpandString(str + 1, buff + 2, sizeof buff - 2, 0);
      ExecStr(physical, buff + 2, buff + 2, sizeof buff - 2);
    } else {
      ExpandString(str, buff + 2, sizeof buff - 2, 1);
    }
    if (strstr(str, "\\P"))	/* Do not log the password itself. */
      LogPrintf(LogCHAT, "Sending: %s", str);
    else {
      cp = buff + strlen(buff + 2) + 1;
      while (cp >= buff + 2 && *cp == '\n')
        cp--;
      LogPrintf(LogCHAT, "Sending: %.*s\n", cp - buff - 1, buff + 2);
    }
    cp = buff;
    if (Physical_IsSync(physical))
      memcpy(buff, "\377\003", 2);	/* Prepend HDLC header */
    else
      cp += 2;
    on = strlen(cp);
    /* XXX - missing return value check */
    Physical_Write(physical, cp, on);
  }
}

static int
ExpectString(struct physical *physical, char *str)
{
  char *minus;
  int state;

  if (strcmp(str, "ABORT") == 0) {
    ++abort_next;
    return (MATCH);
  }
  if (strcmp(str, "TIMEOUT") == 0) {
    ++timeout_next;
    return (MATCH);
  }
  LogPrintf(LogCHAT, "Expecting: %s\n", str);
  while (*str) {
    /*
     * Check whether if string contains sub-send-expect.
     */
    for (minus = str; *minus; minus++) {
      if (*minus == '-') {
	if (minus == str || minus[-1] != '\\')
	  break;
      }
    }
    if (*minus == '-') {	/* We have sub-send-expect. */
      *minus = '\0';	/* XXX: Cheat with the const string */
      state = WaitforString(physical, str);
      *minus = '-';	/* XXX: Cheat with the const string */
      minus++;
      if (state != NOMATCH)
	return (state);

      /*
       * Can't get expect string. Sendout send part.
       */
      str = minus;
      for (minus = str; *minus; minus++) {
	if (*minus == '-') {
	  if (minus == str || minus[-1] != '\\')
	    break;
	}
      }
      if (*minus == '-') {
        *minus = '\0';	/* XXX: Cheat with the const string */
	SendString(physical, str);
        *minus = '-';	/* XXX: Cheat with the const string */
	str = ++minus;
      } else {
	SendString(physical, str);
	return (MATCH);
      }
    } else {
      /*
       * Simple case. Wait for string.
       */
      return (WaitforString(physical, str));
    }
  }
  return (MATCH);
}

static void (*oint) (int);

static void
StopDial(int sig)
{
  LogPrintf(LogPHASE, "DoChat: Caught signal %d, abort connect\n", sig);
  longjmp(ChatEnv, 1);
}

int
DoChat(struct physical *physical, char *script)
{
  char *vector[MAXARGS];
  char *const *argv;
  int argc, n, state, err;

  if (!script || !*script)
    return MATCH;

  if ((err = setjmp(ChatEnv))) {
    signal(SIGINT, oint);
    if (err == 1)
      /* Caught a SIGINT during chat */
      return (-1);
    return (NOMATCH);
  }
  oint = signal(SIGINT, StopDial);

  timeout_next = abort_next = 0;
  for (n = 0; AbortStrings[n]; n++) {
    free(AbortStrings[n]);
    AbortStrings[n] = NULL;
  }
  numaborts = 0;

  memset(vector, '\0', sizeof vector);
  argc = MakeArgs(script, vector, VECSIZE(vector));
  argv = vector;
  TimeoutSec = 30;
  while (*argv) {
    if (strcmp(*argv, "P_ZERO") == 0 ||
	strcmp(*argv, "P_ODD") == 0 || strcmp(*argv, "P_EVEN") == 0) {
      ChangeParity(physical, *argv++);
      continue;
    }
    state = ExpectString(physical, *argv++);
    switch (state) {
    case MATCH:
      if (*argv)
	SendString(physical, *argv++);
      break;
    case ABORT:
    case NOMATCH:
      signal(SIGINT, oint);
      return (NOMATCH);
    }
  }
  signal(SIGINT, oint);
  return (MATCH);
}