From ab5559aaabd1167a18ac882e64d97c5adc0e7d03 Mon Sep 17 00:00:00 2001 From: Guillaume Cottenceau Date: Mon, 11 Jun 2001 11:44:34 +0000 Subject: Initial revision --- mdk-stage1/ppp/chat/Makefile.linux | 27 + mdk-stage1/ppp/chat/Makefile.linux.makeopt | 27 + mdk-stage1/ppp/chat/Makefile.sol2 | 19 + mdk-stage1/ppp/chat/Makefile.sunos4 | 19 + mdk-stage1/ppp/chat/chat.8 | 515 ++++++++ mdk-stage1/ppp/chat/chat.c | 1756 ++++++++++++++++++++++++++++ 6 files changed, 2363 insertions(+) create mode 100644 mdk-stage1/ppp/chat/Makefile.linux create mode 100644 mdk-stage1/ppp/chat/Makefile.linux.makeopt create mode 100644 mdk-stage1/ppp/chat/Makefile.sol2 create mode 100644 mdk-stage1/ppp/chat/Makefile.sunos4 create mode 100644 mdk-stage1/ppp/chat/chat.8 create mode 100644 mdk-stage1/ppp/chat/chat.c (limited to 'mdk-stage1/ppp/chat') diff --git a/mdk-stage1/ppp/chat/Makefile.linux b/mdk-stage1/ppp/chat/Makefile.linux new file mode 100644 index 000000000..586cbd876 --- /dev/null +++ b/mdk-stage1/ppp/chat/Makefile.linux @@ -0,0 +1,27 @@ +# $Id$ + +CDEF1= -DTERMIOS # Use the termios structure +CDEF2= -DSIGTYPE=void # Standard definition +CDEF3= -UNO_SLEEP # Use the usleep function +CDEF4= -DFNDELAY=O_NDELAY # Old name value +CDEFS= $(CDEF1) $(CDEF2) $(CDEF3) $(CDEF4) + +CFLAGS= $(RPM_OPT_FLAGS) $(CDEFS) + +INSTALL= install + +all: chat + +chat: chat.o + $(CC) -o chat chat.o + +chat.o: chat.c + $(CC) -c $(CFLAGS) -o chat.o chat.c + +install: chat + mkdir -p $(BINDIR) + $(INSTALL) -s -c chat $(BINDIR) + $(INSTALL) -c -m 644 chat.8 $(MANDIR)/man8 + +clean: + rm -f chat.o chat *~ diff --git a/mdk-stage1/ppp/chat/Makefile.linux.makeopt b/mdk-stage1/ppp/chat/Makefile.linux.makeopt new file mode 100644 index 000000000..974680a93 --- /dev/null +++ b/mdk-stage1/ppp/chat/Makefile.linux.makeopt @@ -0,0 +1,27 @@ +# $Id$ + +CDEF1= -DTERMIOS # Use the termios structure +CDEF2= -DSIGTYPE=void # Standard definition +CDEF3= -UNO_SLEEP # Use the usleep function +CDEF4= -DFNDELAY=O_NDELAY # Old name value +CDEFS= $(CDEF1) $(CDEF2) $(CDEF3) $(CDEF4) + +CFLAGS= -O2 -g -pipe $(CDEFS) + +INSTALL= install + +all: chat + +chat: chat.o + $(CC) -o chat chat.o + +chat.o: chat.c + $(CC) -c $(CFLAGS) -o chat.o chat.c + +install: chat + mkdir -p $(BINDIR) + $(INSTALL) -s -c chat $(BINDIR) + $(INSTALL) -c -m 644 chat.8 $(MANDIR)/man8 + +clean: + rm -f chat.o chat *~ diff --git a/mdk-stage1/ppp/chat/Makefile.sol2 b/mdk-stage1/ppp/chat/Makefile.sol2 new file mode 100644 index 000000000..f566cc68b --- /dev/null +++ b/mdk-stage1/ppp/chat/Makefile.sol2 @@ -0,0 +1,19 @@ +# +# Makefile for chat on Solaris 2 +# + +include ../solaris/Makedefs + +CFLAGS = $(COPTS) -DNO_USLEEP -DSOL2 + +all: chat + +chat: chat.o + $(CC) -o chat chat.o + +install: chat + $(INSTALL) -f $(BINDIR) chat + $(INSTALL) -m 444 -f $(MANDIR)/man8 chat.8 + +clean: + rm -f *~ *.o chat diff --git a/mdk-stage1/ppp/chat/Makefile.sunos4 b/mdk-stage1/ppp/chat/Makefile.sunos4 new file mode 100644 index 000000000..b3507360e --- /dev/null +++ b/mdk-stage1/ppp/chat/Makefile.sunos4 @@ -0,0 +1,19 @@ +# +# Makefile for chat on suns +# + +include ../sunos4/Makedefs + +CFLAGS = -DSUNOS $(COPTS) + +all: chat + +chat: chat.o + $(CC) -o chat chat.o + +install: chat + $(INSTALL) -c chat $(BINDIR)/chat + $(INSTALL) -c -m 444 chat.8 $(MANDIR)/man8/chat.8 + +clean: + rm -f *~ *.o chat diff --git a/mdk-stage1/ppp/chat/chat.8 b/mdk-stage1/ppp/chat/chat.8 new file mode 100644 index 000000000..8d2029609 --- /dev/null +++ b/mdk-stage1/ppp/chat/chat.8 @@ -0,0 +1,515 @@ +.\" -*- nroff -*- +.\" manual page [] for chat 1.8 +.\" $Id$ +.\" SH section heading +.\" SS subsection heading +.\" LP paragraph +.\" IP indented paragraph +.\" TP hanging label +.TH CHAT 8 "22 May 1999" "Chat Version 1.22" +.SH NAME +chat \- Automated conversational script with a modem +.SH SYNOPSIS +.B chat +[ +.I options +] +.I script +.SH DESCRIPTION +.LP +The \fIchat\fR program defines a conversational exchange between the +computer and the modem. Its primary purpose is to establish the +connection between the Point-to-Point Protocol Daemon (\fIpppd\fR) and +the remote's \fIpppd\fR process. +.SH OPTIONS +.TP +.B -f \fI +Read the chat script from the chat \fIfile\fR. The use of this option +is mutually exclusive with the chat script parameters. The user must +have read access to the file. Multiple lines are permitted in the +file. Space or horizontal tab characters should be used to separate +the strings. +.TP +.B -t \fI +Set the timeout for the expected string to be received. If the string +is not received within the time limit then the reply string is not +sent. An alternate reply may be sent or the script will fail if there +is no alternate reply string. A failed script will cause the +\fIchat\fR program to terminate with a non-zero error code. +.TP +.B -r \fI +Set the file for output of the report strings. If you use the keyword +\fIREPORT\fR, the resulting strings are written to this file. If this +option is not used and you still use \fIREPORT\fR keywords, the +\fIstderr\fR file is used for the report strings. +.TP +.B -e +Start with the echo option turned on. Echoing may also be turned on +or off at specific points in the chat script by using the \fIECHO\fR +keyword. When echoing is enabled, all output from the modem is echoed +to \fIstderr\fR. +.TP +.B -E +Enables environment variable substituion within chat scripts using the +standard \fI$xxx\fR syntax. +.TP +.B -v +Request that the \fIchat\fR script be executed in a verbose mode. The +\fIchat\fR program will then log the execution state of the chat +script as well as all text received from the modem and the output +strings sent to the modem. The default is to log through the SYSLOG; +the logging method may be altered with the -S and -s flags. +.TP +.B -V +Request that the \fIchat\fR script be executed in a stderr verbose +mode. The \fIchat\fR program will then log all text received from the +modem and the output strings sent to the modem to the stderr device. This +device is usually the local console at the station running the chat or +pppd program. +.TP +.B -s +Use stderr. All log messages from '-v' and all error messages will be +sent to stderr. +.TP +.B -S +Do not use the SYSLOG. By default, error messages are sent to the +SYSLOG. The use of -S will prevent both log messages from '-v' and +error messages from being sent to the SYSLOG. +.TP +.B -T \fI +Pass in an arbitary string, usually a phone number, that will be +substituted for the \\T substitution metacharacter in a send string. +.TP +.B -U \fI +Pass in a second string, usually a phone number, that will be +substituted for the \\U substitution metacharacter in a send string. +This is useful when dialing an ISDN terminal adapter that requires two +numbers. +.TP +.B script +If the script is not specified in a file with the \fI-f\fR option then +the script is included as parameters to the \fIchat\fR program. +.SH CHAT SCRIPT +.LP +The \fIchat\fR script defines the communications. +.LP +A script consists of one or more "expect-send" pairs of strings, +separated by spaces, with an optional "subexpect-subsend" string pair, +separated by a dash as in the following example: +.IP +ogin:-BREAK-ogin: ppp ssword: hello2u2 +.LP +This line indicates that the \fIchat\fR program should expect the string +"ogin:". If it fails to receive a login prompt within the time interval +allotted, it is to send a break sequence to the remote and then expect the +string "ogin:". If the first "ogin:" is received then the break sequence is +not generated. +.LP +Once it received the login prompt the \fIchat\fR program will send the +string ppp and then expect the prompt "ssword:". When it receives the +prompt for the password, it will send the password hello2u2. +.LP +A carriage return is normally sent following the reply string. It is not +expected in the "expect" string unless it is specifically requested by using +the \\r character sequence. +.LP +The expect sequence should contain only what is needed to identify the +string. Since it is normally stored on a disk file, it should not contain +variable information. It is generally not acceptable to look for time +strings, network identification strings, or other variable pieces of data as +an expect string. +.LP +To help correct for characters which may be corrupted during the initial +sequence, look for the string "ogin:" rather than "login:". It is possible +that the leading "l" character may be received in error and you may never +find the string even though it was sent by the system. For this reason, +scripts look for "ogin:" rather than "login:" and "ssword:" rather than +"password:". +.LP +A very simple script might look like this: +.IP +ogin: ppp ssword: hello2u2 +.LP +In other words, expect ....ogin:, send ppp, expect ...ssword:, send hello2u2. +.LP +In actual practice, simple scripts are rare. At the vary least, you +should include sub-expect sequences should the original string not be +received. For example, consider the following script: +.IP +ogin:--ogin: ppp ssword: hello2u2 +.LP +This would be a better script than the simple one used earlier. This would look +for the same login: prompt, however, if one was not received, a single +return sequence is sent and then it will look for login: again. Should line +noise obscure the first login prompt then sending the empty line will +usually generate a login prompt again. +.SH COMMENTS +Comments can be embedded in the chat script. A comment is a line which +starts with the \fB#\fR (hash) character in column 1. Such comment +lines are just ignored by the chat program. If a '#' character is to +be expected as the first character of the expect sequence, you should +quote the expect string. +If you want to wait for a prompt that starts with a # (hash) +character, you would have to write something like this: +.IP +# Now wait for the prompt and send logout string +.br +\'# ' logout +.LP + +.SH SENDING DATA FROM A FILE +If the string to send starts with an at sign (@), the rest of the +string is taken to be the name of a file to read to get the string to +send. If the last character of the data read is a newline, it is +removed. The file can be a named pipe (or fifo) instead of a regular +file. This provides a way for \fBchat\fR to communicate with another +program, for example, a program to prompt the user and receive a +password typed in. +.LP + +.SH ABORT STRINGS +Many modems will report the status of the call as a string. These +strings may be \fBCONNECTED\fR or \fBNO CARRIER\fR or \fBBUSY\fR. It +is often desirable to terminate the script should the modem fail to +connect to the remote. The difficulty is that a script would not know +exactly which modem string it may receive. On one attempt, it may +receive \fBBUSY\fR while the next time it may receive \fBNO CARRIER\fR. +.LP +These "abort" strings may be specified in the script using the \fIABORT\fR +sequence. It is written in the script as in the following example: +.IP +ABORT BUSY ABORT 'NO CARRIER' '' ATZ OK ATDT5551212 CONNECT +.LP +This sequence will expect nothing; and then send the string ATZ. The +expected response to this is the string \fIOK\fR. When it receives \fIOK\fR, +the string ATDT5551212 to dial the telephone. The expected string is +\fICONNECT\fR. If the string \fICONNECT\fR is received the remainder of the +script is executed. However, should the modem find a busy telephone, it will +send the string \fIBUSY\fR. This will cause the string to match the abort +character sequence. The script will then fail because it found a match to +the abort string. If it received the string \fINO CARRIER\fR, it will abort +for the same reason. Either string may be received. Either string will +terminate the \fIchat\fR script. +.SH CLR_ABORT STRINGS +This sequence allows for clearing previously set \fBABORT\fR strings. +\fBABORT\fR strings are kept in an array of a pre-determined size (at +compilation time); \fBCLR_ABORT\fR will reclaim the space for cleared +entries so that new strings can use that space. +.SH SAY STRINGS +The \fBSAY\fR directive allows the script to send strings to the user +at the terminal via standard error. If \fBchat\fR is being run by +pppd, and pppd is running as a daemon (detached from its controlling +terminal), standard error will normally be redirected to the file +/etc/ppp/connect-errors. +.LP +\fBSAY\fR strings must be enclosed in single or double quotes. If +carriage return and line feed are needed in the string to be output, +you must explicitely add them to your string. +.LP +The SAY strings could be used to give progress messages in sections of +the script where you want to have 'ECHO OFF' but still let the user +know what is happening. An example is: +.IP +ABORT BUSY +.br +ECHO OFF +.br +SAY "Dialling your ISP...\\n" +.br +\'' ATDT5551212 +.br +TIMEOUT 120 +.br +SAY "Waiting up to 2 minutes for connection ... " +.br +CONNECT '' +.br +SAY "Connected, now logging in ...\n" +.br +ogin: account +.br +ssword: pass +.br +$ \c +SAY "Logged in OK ...\n" +\fIetc ...\fR +.LP +This sequence will only present the SAY strings to the user and all +the details of the script will remain hidden. For example, if the +above script works, the user will see: +.IP +Dialling your ISP... +.br +Waiting up to 2 minutes for connection ... Connected, now logging in ... +.br +Logged in OK ... +.LP + +.SH REPORT STRINGS +A \fBreport\fR string is similar to the ABORT string. The difference +is that the strings, and all characters to the next control character +such as a carriage return, are written to the report file. +.LP +The report strings may be used to isolate the transmission rate of the +modem's connect string and return the value to the chat user. The +analysis of the report string logic occurs in conjunction with the +other string processing such as looking for the expect string. The use +of the same string for a report and abort sequence is probably not +very useful, however, it is possible. +.LP +The report strings to no change the completion code of the program. +.LP +These "report" strings may be specified in the script using the \fIREPORT\fR +sequence. It is written in the script as in the following example: +.IP +REPORT CONNECT ABORT BUSY '' ATDT5551212 CONNECT '' ogin: account +.LP +This sequence will expect nothing; and then send the string +ATDT5551212 to dial the telephone. The expected string is +\fICONNECT\fR. If the string \fICONNECT\fR is received the remainder +of the script is executed. In addition the program will write to the +expect-file the string "CONNECT" plus any characters which follow it +such as the connection rate. +.SH CLR_REPORT STRINGS +This sequence allows for clearing previously set \fBREPORT\fR strings. +\fBREPORT\fR strings are kept in an array of a pre-determined size (at +compilation time); \fBCLR_REPORT\fR will reclaim the space for cleared +entries so that new strings can use that space. +.SH ECHO +The echo options controls whether the output from the modem is echoed +to \fIstderr\fR. This option may be set with the \fI-e\fR option, but +it can also be controlled by the \fIECHO\fR keyword. The "expect-send" +pair \fIECHO\fR \fION\fR enables echoing, and \fIECHO\fR \fIOFF\fR +disables it. With this keyword you can select which parts of the +conversation should be visible. For instance, with the following +script: +.IP +ABORT 'BUSY' +.br +ABORT 'NO CARRIER' +.br +'' ATZ +.br +OK\\r\\n ATD1234567 +.br +\\r\\n \\c +.br +ECHO ON +.br +CONNECT \\c +.br +ogin: account +.LP +all output resulting from modem configuration and dialing is not visible, +but starting with the \fICONNECT\fR (or \fIBUSY\fR) message, everything +will be echoed. +.SH HANGUP +The HANGUP options control whether a modem hangup should be considered +as an error or not. This option is useful in scripts for dialling +systems which will hang up and call your system back. The HANGUP +options can be \fBON\fR or \fBOFF\fR. +.br +When HANGUP is set OFF and the modem hangs up (e.g., after the first +stage of logging in to a callback system), \fBchat\fR will continue +running the script (e.g., waiting for the incoming call and second +stage login prompt). As soon as the incoming call is connected, you +should use the \fBHANGUP ON\fR directive to reinstall normal hang up +signal behavior. Here is an (simple) example script: +.IP +ABORT 'BUSY' +.br +'' ATZ +.br +OK\\r\\n ATD1234567 +.br +\\r\\n \\c +.br +CONNECT \\c +.br +\'Callback login:' call_back_ID +.br +HANGUP OFF +.br +ABORT "Bad Login" +.br +\'Callback Password:' Call_back_password +.br +TIMEOUT 120 +.br +CONNECT \\c +.br +HANGUP ON +.br +ABORT "NO CARRIER" +.br +ogin:--BREAK--ogin: real_account +.br +\fIetc ...\fR +.LP +.SH TIMEOUT +The initial timeout value is 45 seconds. This may be changed using the \fB-t\fR +parameter. +.LP +To change the timeout value for the next expect string, the following +example may be used: +.IP +ATZ OK ATDT5551212 CONNECT TIMEOUT 10 ogin:--ogin: TIMEOUT 5 assword: hello2u2 +.LP +This will change the timeout to 10 seconds when it expects the login: +prompt. The timeout is then changed to 5 seconds when it looks for the +password prompt. +.LP +The timeout, once changed, remains in effect until it is changed again. +.SH SENDING EOT +The special reply string of \fIEOT\fR indicates that the chat program +should send an EOT character to the remote. This is normally the +End-of-file character sequence. A return character is not sent +following the EOT. +.PR +The EOT sequence may be embedded into the send string using the +sequence \fI^D\fR. +.SH GENERATING BREAK +The special reply string of \fIBREAK\fR will cause a break condition +to be sent. The break is a special signal on the transmitter. The +normal processing on the receiver is to change the transmission rate. +It may be used to cycle through the available transmission rates on +the remote until you are able to receive a valid login prompt. +.PR +The break sequence may be embedded into the send string using the +\fI\\K\fR sequence. +.SH ESCAPE SEQUENCES +The expect and reply strings may contain escape sequences. All of the +sequences are legal in the reply string. Many are legal in the expect. +Those which are not valid in the expect sequence are so indicated. +.TP +.B '' +Expects or sends a null string. If you send a null string then it will still +send the return character. This sequence may either be a pair of apostrophe +or quote characters. +.TP +.B \\\\b +represents a backspace character. +.TP +.B \\\\c +Suppresses the newline at the end of the reply string. This is the only +method to send a string without a trailing return character. It must +be at the end of the send string. For example, +the sequence hello\\c will simply send the characters h, e, l, l, o. +.I (not valid in expect.) +.TP +.B \\\\d +Delay for one second. The program uses sleep(1) which will delay to a +maximum of one second. +.I (not valid in expect.) +.TP +.B \\\\K +Insert a BREAK +.I (not valid in expect.) +.TP +.B \\\\n +Send a newline or linefeed character. +.TP +.B \\\\N +Send a null character. The same sequence may be represented by \\0. +.I (not valid in expect.) +.TP +.B \\\\p +Pause for a fraction of a second. The delay is 1/10th of a second. +.I (not valid in expect.) +.TP +.B \\\\q +Suppress writing the string to the SYSLOG file. The string ?????? is +written to the log in its place. +.I (not valid in expect.) +.TP +.B \\\\r +Send or expect a carriage return. +.TP +.B \\\\s +Represents a space character in the string. This may be used when it +is not desirable to quote the strings which contains spaces. The +sequence 'HI TIM' and HI\\sTIM are the same. +.TP +.B \\\\t +Send or expect a tab character. +.TP +.B \\\\T +Send the phone number string as specified with the \fI-T\fR option +.I (not valid in expect.) +.TP +.B \\\\U +Send the phone number 2 string as specified with the \fI-U\fR option +.I (not valid in expect.) +.TP +.B \\\\\\\\ +Send or expect a backslash character. +.TP +.B \\\\ddd +Collapse the octal digits (ddd) into a single ASCII character and send that +character. +.I (some characters are not valid in expect.) +.TP +.B \^^C +Substitute the sequence with the control character represented by C. +For example, the character DC1 (17) is shown as \^^Q. +.I (some characters are not valid in expect.) +.SH ENVIRONMENT VARIABLES +Environment variables are available within chat scripts, if the \fI-E\fR +option was specified in the command line. The metacharacter \fI$\fR is used +to introduce the name of the environment variable to substitute. If the +substition fails, because the requested environment variable is not set, +\fInothing\fR is replaced for the variable. +.SH TERMINATION CODES +The \fIchat\fR program will terminate with the following completion +codes. +.TP +.B 0 +The normal termination of the program. This indicates that the script +was executed without error to the normal conclusion. +.TP +.B 1 +One or more of the parameters are invalid or an expect string was too +large for the internal buffers. This indicates that the program as not +properly executed. +.TP +.B 2 +An error occurred during the execution of the program. This may be due +to a read or write operation failing for some reason or chat receiving +a signal such as SIGINT. +.TP +.B 3 +A timeout event occurred when there was an \fIexpect\fR string without +having a "-subsend" string. This may mean that you did not program the +script correctly for the condition or that some unexpected event has +occurred and the expected string could not be found. +.TP +.B 4 +The first string marked as an \fIABORT\fR condition occurred. +.TP +.B 5 +The second string marked as an \fIABORT\fR condition occurred. +.TP +.B 6 +The third string marked as an \fIABORT\fR condition occurred. +.TP +.B 7 +The fourth string marked as an \fIABORT\fR condition occurred. +.TP +.B ... +The other termination codes are also strings marked as an \fIABORT\fR +condition. +.LP +Using the termination code, it is possible to determine which event +terminated the script. It is possible to decide if the string "BUSY" +was received from the modem as opposed to "NO DIAL TONE". While the +first event may be retried, the second will probably have little +chance of succeeding during a retry. +.SH SEE ALSO +Additional information about \fIchat\fR scripts may be found with UUCP +documentation. The \fIchat\fR script was taken from the ideas proposed +by the scripts used by the \fIuucico\fR program. +.LP +uucico(1), uucp(1) +.SH COPYRIGHT +The \fIchat\fR program is in public domain. This is not the GNU public +license. If it breaks then you get to keep both pieces. diff --git a/mdk-stage1/ppp/chat/chat.c b/mdk-stage1/ppp/chat/chat.c new file mode 100644 index 000000000..1b22907a8 --- /dev/null +++ b/mdk-stage1/ppp/chat/chat.c @@ -0,0 +1,1756 @@ +/* + * Chat -- a program for automatic session establishment (i.e. dial + * the phone and log in). + * + * Standard termination codes: + * 0 - successful completion of the script + * 1 - invalid argument, expect string too large, etc. + * 2 - error on an I/O operation or fatal error condition. + * 3 - timeout waiting for a simple string. + * 4 - the first string declared as "ABORT" + * 5 - the second string declared as "ABORT" + * 6 - ... and so on for successive ABORT strings. + * + * This software is in the public domain. + * + * ----------------- + * 22-May-99 added environment substitutuion, enabled with -E switch. + * Andreas Arens . + * + * 12-May-99 added a feature to read data to be sent from a file, + * if the send string starts with @. Idea from gpk . + * + * added -T and -U option and \T and \U substitution to pass a phone + * number into chat script. Two are needed for some ISDN TA applications. + * Keith Dart + * + * + * Added SAY keyword to send output to stderr. + * This allows to turn ECHO OFF and to output specific, user selected, + * text to give progress messages. This best works when stderr + * exists (i.e.: pppd in nodetach mode). + * + * Added HANGUP directives to allow for us to be called + * back. When HANGUP is set to NO, chat will not hangup at HUP signal. + * We rely on timeouts in that case. + * + * Added CLR_ABORT to clear previously set ABORT string. This has been + * dictated by the HANGUP above as "NO CARRIER" (for example) must be + * an ABORT condition until we know the other host is going to close + * the connection for call back. As soon as we have completed the + * first stage of the call back sequence, "NO CARRIER" is a valid, non + * fatal string. As soon as we got called back (probably get "CONNECT"), + * we should re-arm the ABORT "NO CARRIER". Hence the CLR_ABORT command. + * Note that CLR_ABORT packs the abort_strings[] array so that we do not + * have unused entries not being reclaimed. + * + * In the same vein as above, added CLR_REPORT keyword. + * + * Allow for comments. Line starting with '#' are comments and are + * ignored. If a '#' is to be expected as the first character, the + * expect string must be quoted. + * + * + * Francis Demierre + * Thu May 15 17:15:40 MET DST 1997 + * + * + * Added -r "report file" switch & REPORT keyword. + * Robert Geer + * + * Added -s "use stderr" and -S "don't use syslog" switches. + * June 18, 1997 + * Karl O. Pinc + * + * + * Added -e "echo" switch & ECHO keyword + * Dick Streefland + * + * + * Considerable updates and modifications by + * Al Longyear + * Paul Mackerras + * + * + * The original author is: + * + * Karl Fox + * Morning Star Technologies, Inc. + * 1760 Zollinger Road + * Columbus, OH 43221 + * (614)451-1883 + * + */ + +#ifndef __STDC__ +#define const +#endif + +#ifndef lint +static const char rcsid[] = "$Id$"; +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifndef TERMIO +#undef TERMIOS +#define TERMIOS +#endif + +#ifdef TERMIO +#include +#endif +#ifdef TERMIOS +#include +#endif + +#define STR_LEN 1024 + +#ifndef SIGTYPE +#define SIGTYPE void +#endif + +#undef __P +#undef __V + +#ifdef __STDC__ +#include +#define __V(x) x +#define __P(x) x +#else +#include +#define __V(x) (va_alist) va_dcl +#define __P(x) () +#define const +#endif + +#ifndef O_NONBLOCK +#define O_NONBLOCK O_NDELAY +#endif + +#ifdef SUNOS +extern int sys_nerr; +extern char *sys_errlist[]; +#define memmove(to, from, n) bcopy(from, to, n) +#define strerror(n) ((unsigned)(n) < sys_nerr? sys_errlist[(n)] :\ + "unknown error") +#endif + +/*************** Micro getopt() *********************************************/ +#define OPTION(c,v) (_O&2&&**v?*(*v)++:!c||_O&4?0:(!(_O&1)&& \ + (--c,++v),_O=4,c&&**v=='-'&&v[0][1]?*++*v=='-'\ + &&!v[0][1]?(--c,++v,0):(_O=2,*(*v)++):0)) +#define OPTARG(c,v) (_O&2?**v||(++v,--c)?(_O=1,--c,*v++): \ + (_O=4,(char*)0):(char*)0) +#define OPTONLYARG(c,v) (_O&2&&**v?(_O=1,--c,*v++):(char*)0) +#define ARG(c,v) (c?(--c,*v++):(char*)0) + +static int _O = 0; /* Internal state */ +/*************** Micro getopt() *********************************************/ + +char *program_name; + +#define MAX_ABORTS 50 +#define MAX_REPORTS 50 +#define DEFAULT_CHAT_TIMEOUT 45 + +int echo = 0; +int verbose = 0; +int to_log = 1; +int to_stderr = 0; +int Verbose = 0; +int quiet = 0; +int report = 0; +int use_env = 0; +int exit_code = 0; +FILE* report_fp = (FILE *) 0; +char *report_file = (char *) 0; +char *chat_file = (char *) 0; +char *phone_num = (char *) 0; +char *phone_num2 = (char *) 0; +int timeout = DEFAULT_CHAT_TIMEOUT; + +int have_tty_parameters = 0; + +#ifdef TERMIO +#define term_parms struct termio +#define get_term_param(param) ioctl(0, TCGETA, param) +#define set_term_param(param) ioctl(0, TCSETA, param) +struct termio saved_tty_parameters; +#endif + +#ifdef TERMIOS +#define term_parms struct termios +#define get_term_param(param) tcgetattr(0, param) +#define set_term_param(param) tcsetattr(0, TCSANOW, param) +struct termios saved_tty_parameters; +#endif + +char *abort_string[MAX_ABORTS], *fail_reason = (char *)0, + fail_buffer[50]; +int n_aborts = 0, abort_next = 0, timeout_next = 0, echo_next = 0; +int clear_abort_next = 0; + +char *report_string[MAX_REPORTS] ; +char report_buffer[50] ; +int n_reports = 0, report_next = 0, report_gathering = 0 ; +int clear_report_next = 0; + +int say_next = 0, hup_next = 0; + +void *dup_mem __P((void *b, size_t c)); +void *copy_of __P((char *s)); +void usage __P((void)); +void logf __P((const char *fmt, ...)); +void fatal __P((int code, const char *fmt, ...)); +SIGTYPE sigalrm __P((int signo)); +SIGTYPE sigint __P((int signo)); +SIGTYPE sigterm __P((int signo)); +SIGTYPE sighup __P((int signo)); +void unalarm __P((void)); +void init __P((void)); +void set_tty_parameters __P((void)); +void echo_stderr __P((int)); +void break_sequence __P((void)); +void terminate __P((int status)); +void do_file __P((char *chat_file)); +int get_string __P((register char *string)); +int put_string __P((register char *s)); +int write_char __P((int c)); +int put_char __P((int c)); +int get_char __P((void)); +void chat_send __P((register char *s)); +char *character __P((int c)); +void chat_expect __P((register char *s)); +char *clean __P((register char *s, int sending)); +void break_sequence __P((void)); +void terminate __P((int status)); +void pack_array __P((char **array, int end)); +char *expect_strtok __P((char *, char *)); +int vfmtmsg __P((char *, int, const char *, va_list)); /* vsprintf++ */ + +int main __P((int, char *[])); + +void *dup_mem(b, c) +void *b; +size_t c; +{ + void *ans = malloc (c); + if (!ans) + fatal(2, "memory error!"); + + memcpy (ans, b, c); + return ans; +} + +void *copy_of (s) +char *s; +{ + return dup_mem (s, strlen (s) + 1); +} + +/* + * chat [ -v ] [ -E ] [ -T number ] [ -U number ] [ -t timeout ] [ -f chat-file ] \ + * [ -r report-file ] \ + * [...[[expect[-say[-expect...]] say expect[-say[-expect]] ...]]] + * + * Perform a UUCP-dialer-like chat script on stdin and stdout. + */ +int +main(argc, argv) + int argc; + char **argv; +{ + int option; + char *arg; + + program_name = *argv; + tzset(); + + while ((option = OPTION(argc, argv)) != 0) { + switch (option) { + case 'e': + ++echo; + break; + + case 'E': + ++use_env; + break; + + case 'v': + ++verbose; + break; + + case 'V': + ++Verbose; + break; + + case 's': + ++to_stderr; + break; + + case 'S': + to_log = 0; + break; + + case 'f': + if ((arg = OPTARG(argc, argv)) != NULL) + chat_file = copy_of(arg); + else + usage(); + break; + + case 't': + if ((arg = OPTARG(argc, argv)) != NULL) + timeout = atoi(arg); + else + usage(); + break; + + case 'r': + arg = OPTARG (argc, argv); + if (arg) { + if (report_fp != NULL) + fclose (report_fp); + report_file = copy_of (arg); + report_fp = fopen (report_file, "a"); + if (report_fp != NULL) { + if (verbose) + fprintf (report_fp, "Opening \"%s\"...\n", + report_file); + report = 1; + } + } + break; + + case 'T': + if ((arg = OPTARG(argc, argv)) != NULL) + phone_num = copy_of(arg); + else + usage(); + break; + + case 'U': + if ((arg = OPTARG(argc, argv)) != NULL) + phone_num2 = copy_of(arg); + else + usage(); + break; + + default: + usage(); + break; + } + } +/* + * Default the report file to the stderr location + */ + if (report_fp == NULL) + report_fp = stderr; + + if (to_log) { +#ifdef ultrix + openlog("chat", LOG_PID); +#else + openlog("chat", LOG_PID | LOG_NDELAY, LOG_LOCAL2); + + if (verbose) + setlogmask(LOG_UPTO(LOG_INFO)); + else + setlogmask(LOG_UPTO(LOG_WARNING)); +#endif + } + + init(); + + if (chat_file != NULL) { + arg = ARG(argc, argv); + if (arg != NULL) + usage(); + else + do_file (chat_file); + } else { + while ((arg = ARG(argc, argv)) != NULL) { + chat_expect(arg); + + if ((arg = ARG(argc, argv)) != NULL) + chat_send(arg); + } + } + + terminate(0); + return 0; +} + +/* + * Process a chat script when read from a file. + */ + +void do_file (chat_file) +char *chat_file; +{ + int linect, sendflg; + char *sp, *arg, quote; + char buf [STR_LEN]; + FILE *cfp; + + cfp = fopen (chat_file, "r"); + if (cfp == NULL) + fatal(1, "%s -- open failed: %m", chat_file); + + linect = 0; + sendflg = 0; + + while (fgets(buf, STR_LEN, cfp) != NULL) { + sp = strchr (buf, '\n'); + if (sp) + *sp = '\0'; + + linect++; + sp = buf; + + /* lines starting with '#' are comments. If a real '#' + is to be expected, it should be quoted .... */ + if ( *sp == '#' ) + continue; + + while (*sp != '\0') { + if (*sp == ' ' || *sp == '\t') { + ++sp; + continue; + } + + if (*sp == '"' || *sp == '\'') { + quote = *sp++; + arg = sp; + while (*sp != quote) { + if (*sp == '\0') + fatal(1, "unterminated quote (line %d)", linect); + + if (*sp++ == '\\') { + if (*sp != '\0') + ++sp; + } + } + } + else { + arg = sp; + while (*sp != '\0' && *sp != ' ' && *sp != '\t') + ++sp; + } + + if (*sp != '\0') + *sp++ = '\0'; + + if (sendflg) + chat_send (arg); + else + chat_expect (arg); + sendflg = !sendflg; + } + } + fclose (cfp); +} + +/* + * We got an error parsing the command line. + */ +void usage() +{ + fprintf(stderr, "\ +Usage: %s [-e] [-E] [-v] [-V] [-t timeout] [-r report-file]\n\ + [-T phone-number] [-U phone-number2] {-f chat-file | chat-script}\n", program_name); + exit(1); +} + +char line[1024]; + +/* + * Send a message to syslog and/or stderr. + */ +void logf __V((const char *fmt, ...)) +{ + va_list args; + +#ifdef __STDC__ + va_start(args, fmt); +#else + char *fmt; + va_start(args); + fmt = va_arg(args, char *); +#endif + + vfmtmsg(line, sizeof(line), fmt, args); + if (to_log) + syslog(LOG_INFO, "%s", line); + if (to_stderr) + fprintf(stderr, "%s\n", line); +} + +/* + * Print an error message and terminate. + */ + +void fatal __V((int code, const char *fmt, ...)) +{ + va_list args; + +#ifdef __STDC__ + va_start(args, fmt); +#else + int code; + char *fmt; + va_start(args); + code = va_arg(args, int); + fmt = va_arg(args, char *); +#endif + + vfmtmsg(line, sizeof(line), fmt, args); + if (to_log) + syslog(LOG_ERR, "%s", line); + if (to_stderr) + fprintf(stderr, "%s\n", line); + terminate(code); +} + +int alarmed = 0; + +SIGTYPE sigalrm(signo) +int signo; +{ + int flags; + + alarm(1); + alarmed = 1; /* Reset alarm to avoid race window */ + signal(SIGALRM, sigalrm); /* that can cause hanging in read() */ + + if ((flags = fcntl(0, F_GETFL, 0)) == -1) + fatal(2, "Can't get file mode flags on stdin: %m"); + + if (fcntl(0, F_SETFL, flags | O_NONBLOCK) == -1) + fatal(2, "Can't set file mode flags on stdin: %m"); + + if (verbose) + logf("alarm"); +} + +void unalarm() +{ + int flags; + + if ((flags = fcntl(0, F_GETFL, 0)) == -1) + fatal(2, "Can't get file mode flags on stdin: %m"); + + if (fcntl(0, F_SETFL, flags & ~O_NONBLOCK) == -1) + fatal(2, "Can't set file mode flags on stdin: %m"); +} + +SIGTYPE sigint(signo) +int signo; +{ + fatal(2, "SIGINT"); +} + +SIGTYPE sigterm(signo) +int signo; +{ + fatal(2, "SIGTERM"); +} + +SIGTYPE sighup(signo) +int signo; +{ + fatal(2, "SIGHUP"); +} + +void init() +{ + signal(SIGINT, sigint); + signal(SIGTERM, sigterm); + signal(SIGHUP, sighup); + + set_tty_parameters(); + signal(SIGALRM, sigalrm); + alarm(0); + alarmed = 0; +} + +void set_tty_parameters() +{ +#if defined(get_term_param) + term_parms t; + + if (get_term_param (&t) < 0) + fatal(2, "Can't get terminal parameters: %m"); + + saved_tty_parameters = t; + have_tty_parameters = 1; + + t.c_iflag |= IGNBRK | ISTRIP | IGNPAR; + t.c_oflag = 0; + t.c_lflag = 0; + t.c_cc[VERASE] = + t.c_cc[VKILL] = 0; + t.c_cc[VMIN] = 1; + t.c_cc[VTIME] = 0; + + if (set_term_param (&t) < 0) + fatal(2, "Can't set terminal parameters: %m"); +#endif +} + +void break_sequence() +{ +#ifdef TERMIOS + tcsendbreak (0, 0); +#endif +} + +void terminate(status) +int status; +{ + static int terminating = 0; + + if (terminating) + exit(status); + terminating = 1; + echo_stderr(-1); +/* + * Allow the last of the report string to be gathered before we terminate. + */ + if (report_gathering) { + int c, rep_len; + + rep_len = strlen(report_buffer); + while (rep_len + 1 <= sizeof(report_buffer)) { + alarm(1); + c = get_char(); + alarm(0); + if (c < 0 || iscntrl(c)) + break; + report_buffer[rep_len] = c; + ++rep_len; + } + report_buffer[rep_len] = 0; + fprintf (report_fp, "chat: %s\n", report_buffer); + } + if (report_file != (char *) 0 && report_fp != (FILE *) NULL) { + if (verbose) + fprintf (report_fp, "Closing \"%s\".\n", report_file); + fclose (report_fp); + report_fp = (FILE *) NULL; + } + +#if defined(get_term_param) + if (have_tty_parameters) { + if (set_term_param (&saved_tty_parameters) < 0) + fatal(2, "Can't restore terminal parameters: %m"); + } +#endif + + exit(status); +} + +/* + * 'Clean up' this string. + */ +char *clean(s, sending) +register char *s; +int sending; /* set to 1 when sending (putting) this string. */ +{ + char temp[STR_LEN], env_str[STR_LEN], cur_chr; + register char *s1, *phchar; + int add_return = sending; +#define isoctal(chr) (((chr) >= '0') && ((chr) <= '7')) +#define isalnumx(chr) ((((chr) >= '0') && ((chr) <= '9')) \ + || (((chr) >= 'a') && ((chr) <= 'z')) \ + || (((chr) >= 'A') && ((chr) <= 'Z')) \ + || (chr) == '_') + + s1 = temp; + while (*s) { + cur_chr = *s++; + if (cur_chr == '^') { + cur_chr = *s++; + if (cur_chr == '\0') { + *s1++ = '^'; + break; + } + cur_chr &= 0x1F; + if (cur_chr != 0) { + *s1++ = cur_chr; + } + continue; + } + + if (use_env && cur_chr == '$') { /* ARI */ + phchar = env_str; + while (isalnumx(*s)) + *phchar++ = *s++; + *phchar = '\0'; + phchar = getenv(env_str); + if (phchar) + while (*phchar) + *s1++ = *phchar++; + continue; + } + + if (cur_chr != '\\') { + *s1++ = cur_chr; + continue; + } + + cur_chr = *s++; + if (cur_chr == '\0') { + if (sending) { + *s1++ = '\\'; + *s1++ = '\\'; + } + break; + } + + switch (cur_chr) { + case 'b': + *s1++ = '\b'; + break; + + case 'c': + if (sending && *s == '\0') + add_return = 0; + else + *s1++ = cur_chr; + break; + + case '\\': + case 'K': + case 'p': + case 'd': + if (sending) + *s1++ = '\\'; + *s1++ = cur_chr; + break; + + case 'T': + if (sending && phone_num) { + for (phchar = phone_num; *phchar != '\0'; phchar++) + *s1++ = *phchar; + } + else { + *s1++ = '\\'; + *s1++ = 'T'; + } + break; + + case 'U': + if (sending && phone_num2) { + for (phchar = phone_num2; *phchar != '\0'; phchar++) + *s1++ = *phchar; + } + else { + *s1++ = '\\'; + *s1++ = 'U'; + } + break; + + case 'q': + quiet = 1; + break; + + case 'r': + *s1++ = '\r'; + break; + + case 'n': + *s1++ = '\n'; + break; + + case 's': + *s1++ = ' '; + break; + + case 't': + *s1++ = '\t'; + break; + + case 'N': + if (sending) { + *s1++ = '\\'; + *s1++ = '\0'; + } + else + *s1++ = 'N'; + break; + + case '$': /* ARI */ + if (use_env) { + *s1++ = cur_chr; + break; + } + /* FALL THROUGH */ + + default: + if (isoctal (cur_chr)) { + cur_chr &= 0x07; + if (isoctal (*s)) { + cur_chr <<= 3; + cur_chr |= *s++ - '0'; + if (isoctal (*s)) { + cur_chr <<= 3; + cur_chr |= *s++ - '0'; + } + } + + if (cur_chr != 0 || sending) { + if (sending && (cur_chr == '\\' || cur_chr == 0)) + *s1++ = '\\'; + *s1++ = cur_chr; + } + break; + } + + if (sending) + *s1++ = '\\'; + *s1++ = cur_chr; + break; + } + } + + if (add_return) + *s1++ = '\r'; + + *s1++ = '\0'; /* guarantee closure */ + *s1++ = '\0'; /* terminate the string */ + return dup_mem (temp, (size_t) (s1 - temp)); /* may have embedded nuls */ +} + +/* + * A modified version of 'strtok'. This version skips \ sequences. + */ + +char *expect_strtok (s, term) + char *s, *term; +{ + static char *str = ""; + int escape_flag = 0; + char *result; + +/* + * If a string was specified then do initial processing. + */ + if (s) + str = s; + +/* + * If this is the escape flag then reset it and ignore the character. + */ + if (*str) + result = str; + else + result = (char *) 0; + + while (*str) { + if (escape_flag) { + escape_flag = 0; + ++str; + continue; + } + + if (*str == '\\') { + ++str; + escape_flag = 1; + continue; + } + +/* + * If this is not in the termination string, continue. + */ + if (strchr (term, *str) == (char *) 0) { + ++str; + continue; + } + +/* + * This is the terminator. Mark the end of the string and stop. + */ + *str++ = '\0'; + break; + } + return (result); +} + +/* + * Process the expect string + */ + +void chat_expect (s) +char *s; +{ + char *expect; + char *reply; + + if (strcmp(s, "HANGUP") == 0) { + ++hup_next; + return; + } + + if (strcmp(s, "ABORT") == 0) { + ++abort_next; + return; + } + + if (strcmp(s, "CLR_ABORT") == 0) { + ++clear_abort_next; + return; + } + + if (strcmp(s, "REPORT") == 0) { + ++report_next; + return; + } + + if (strcmp(s, "CLR_REPORT") == 0) { + ++clear_report_next; + return; + } + + if (strcmp(s, "TIMEOUT") == 0) { + ++timeout_next; + return; + } + + if (strcmp(s, "ECHO") == 0) { + ++echo_next; + return; + } + + if (strcmp(s, "SAY") == 0) { + ++say_next; + return; + } + +/* + * Fetch the expect and reply string. + */ + for (;;) { + expect = expect_strtok (s, "-"); + s = (char *) 0; + + if (expect == (char *) 0) + return; + + reply = expect_strtok (s, "-"); + +/* + * Handle the expect string. If successful then exit. + */ + if (get_string (expect)) + return; + +/* + * If there is a sub-reply string then send it. Otherwise any condition + * is terminal. + */ + if (reply == (char *) 0 || exit_code != 3) + break; + + chat_send (reply); + } + +/* + * The expectation did not occur. This is terminal. + */ + if (fail_reason) + logf("Failed (%s)", fail_reason); + else + logf("Failed"); + terminate(exit_code); +} + +/* + * Translate the input character to the appropriate string for printing + * the data. + */ + +char *character(c) +int c; +{ + static char string[10]; + char *meta; + + meta = (c & 0x80) ? "M-" : ""; + c &= 0x7F; + + if (c < 32) + sprintf(string, "%s^%c", meta, (int)c + '@'); + else if (c == 127) + sprintf(string, "%s^?", meta); + else + sprintf(string, "%s%c", meta, c); + + return (string); +} + +/* + * process the reply string + */ +void chat_send (s) +register char *s; +{ + char file_data[STR_LEN]; + + if (say_next) { + say_next = 0; + s = clean(s, 1); + write(2, s, strlen(s)); + free(s); + return; + } + + if (hup_next) { + hup_next = 0; + if (strcmp(s, "OFF") == 0) + signal(SIGHUP, SIG_IGN); + else + signal(SIGHUP, sighup); + return; + } + + if (echo_next) { + echo_next = 0; + echo = (strcmp(s, "ON") == 0); + return; + } + + if (abort_next) { + char *s1; + + abort_next = 0; + + if (n_aborts >= MAX_ABORTS) + fatal(2, "Too many ABORT strings"); + + s1 = clean(s, 0); + + if (strlen(s1) > strlen(s) + || strlen(s1) + 1 > sizeof(fail_buffer)) + fatal(1, "Illegal or too-long ABORT string ('%v')", s); + + abort_string[n_aborts++] = s1; + + if (verbose) + logf("abort on (%v)", s); + return; + } + + if (clear_abort_next) { + char *s1; + int i; + int old_max; + int pack = 0; + + clear_abort_next = 0; + + s1 = clean(s, 0); + + if (strlen(s1) > strlen(s) + || strlen(s1) + 1 > sizeof(fail_buffer)) + fatal(1, "Illegal or too-long CLR_ABORT string ('%v')", s); + + old_max = n_aborts; + for (i=0; i < n_aborts; i++) { + if ( strcmp(s1,abort_string[i]) == 0 ) { + free(abort_string[i]); + abort_string[i] = NULL; + pack++; + n_aborts--; + if (verbose) + logf("clear abort on (%v)", s); + } + } + free(s1); + if (pack) + pack_array(abort_string,old_max); + return; + } + + if (report_next) { + char *s1; + + report_next = 0; + if (n_reports >= MAX_REPORTS) + fatal(2, "Too many REPORT strings"); + + s1 = clean(s, 0); + + if (strlen(s1) > strlen(s) || strlen(s1) > sizeof fail_buffer - 1) + fatal(1, "Illegal or too-long REPORT string ('%v')", s); + + report_string[n_reports++] = s1; + + if (verbose) + logf("report (%v)", s); + return; + } + + if (clear_report_next) { + char *s1; + int i; + int old_max; + int pack = 0; + + clear_report_next = 0; + + s1 = clean(s, 0); + + if (strlen(s1) > strlen(s) || strlen(s1) > sizeof fail_buffer - 1) + fatal(1, "Illegal or too-long REPORT string ('%v')", s); + + old_max = n_reports; + for (i=0; i < n_reports; i++) { + if ( strcmp(s1,report_string[i]) == 0 ) { + free(report_string[i]); + report_string[i] = NULL; + pack++; + n_reports--; + if (verbose) + logf("clear report (%v)", s); + } + } + free(s1); + if (pack) + pack_array(report_string,old_max); + + return; + } + + if (timeout_next) { + timeout_next = 0; + timeout = atoi(s); + + if (timeout <= 0) + timeout = DEFAULT_CHAT_TIMEOUT; + + if (verbose) + logf("timeout set to %d seconds", timeout); + + return; + } + + /* + * The syntax @filename means read the string to send from the + * file `filename'. + */ + if (s[0] == '@') { + /* skip the @ and any following white-space */ + char *fn = s; + while (*++fn == ' ' || *fn == '\t') + ; + + if (*fn != 0) { + FILE *f; + int n = 0; + + /* open the file and read until STR_LEN-1 bytes or end-of-file */ + f = fopen(fn, "r"); + if (f == NULL) + fatal(1, "%s -- open failed: %m", fn); + while (n < STR_LEN - 1) { + int nr = fread(&file_data[n], 1, STR_LEN - 1 - n, f); + if (nr < 0) + fatal(1, "%s -- read error", fn); + if (nr == 0) + break; + n += nr; + } + fclose(f); + + /* use the string we got as the string to send, + but trim off the final newline if any. */ + if (n > 0 && file_data[n-1] == '\n') + --n; + file_data[n] = 0; + s = file_data; + } + } + + if (strcmp(s, "EOT") == 0) + s = "^D\\c"; + else if (strcmp(s, "BREAK") == 0) + s = "\\K\\c"; + + if (!put_string(s)) + fatal(1, "Failed"); +} + +int get_char() +{ + int status; + char c; + + status = read(0, &c, 1); + + switch (status) { + case 1: + return ((int)c & 0x7F); + + default: + logf("warning: read() on stdin returned %d", status); + + case -1: + if ((status = fcntl(0, F_GETFL, 0)) == -1) + fatal(2, "Can't get file mode flags on stdin: %m"); + + if (fcntl(0, F_SETFL, status & ~O_NONBLOCK) == -1) + fatal(2, "Can't set file mode flags on stdin: %m"); + + return (-1); + } +} + +int put_char(c) +int c; +{ + int status; + char ch = c; + + usleep(10000); /* inter-character typing delay (?) */ + + status = write(1, &ch, 1); + + switch (status) { + case 1: + return (0); + + default: + logf("warning: write() on stdout returned %d", status); + + case -1: + if ((status = fcntl(0, F_GETFL, 0)) == -1) + fatal(2, "Can't get file mode flags on stdin, %m"); + + if (fcntl(0, F_SETFL, status & ~O_NONBLOCK) == -1) + fatal(2, "Can't set file mode flags on stdin: %m"); + + return (-1); + } +} + +int write_char (c) +int c; +{ + if (alarmed || put_char(c) < 0) { + alarm(0); + alarmed = 0; + + if (verbose) { + if (errno == EINTR || errno == EWOULDBLOCK) + logf(" -- write timed out"); + else + logf(" -- write failed: %m"); + } + return (0); + } + return (1); +} + +int put_string (s) +register char *s; +{ + quiet = 0; + s = clean(s, 1); + + if (verbose) { + if (quiet) + logf("send (??????)"); + else + logf("send (%v)", s); + } + + alarm(timeout); alarmed = 0; + + while (*s) { + register char c = *s++; + + if (c != '\\') { + if (!write_char (c)) + return 0; + continue; + } + + c = *s++; + switch (c) { + case 'd': + sleep(1); + break; + + case 'K': + break_sequence(); + break; + + case 'p': + usleep(10000); /* 1/100th of a second (arg is microseconds) */ + break; + + default: + if (!write_char (c)) + return 0; + break; + } + } + + alarm(0); + alarmed = 0; + return (1); +} + +/* + * Echo a character to stderr. + * When called with -1, a '\n' character is generated when + * the cursor is not at the beginning of a line. + */ +void echo_stderr(n) +int n; +{ + static int need_lf; + char *s; + + switch (n) { + case '\r': /* ignore '\r' */ + break; + case -1: + if (need_lf == 0) + break; + /* fall through */ + case '\n': + write(2, "\n", 1); + need_lf = 0; + break; + default: + s = character(n); + write(2, s, strlen(s)); + need_lf = 1; + break; + } +} + +/* + * 'Wait for' this string to appear on this file descriptor. + */ +int get_string(string) +register char *string; +{ + char temp[STR_LEN]; + int c, printed = 0, len, minlen; + register char *s = temp, *end = s + STR_LEN; + char *logged = temp; + + fail_reason = (char *)0; + string = clean(string, 0); + len = strlen(string); + minlen = (len > sizeof(fail_buffer)? len: sizeof(fail_buffer)) - 1; + + if (verbose) + logf("expect (%v)", string); + + if (len > STR_LEN) { + logf("expect string is too long"); + exit_code = 1; + return 0; + } + + if (len == 0) { + if (verbose) + logf("got it"); + return (1); + } + + alarm(timeout); + alarmed = 0; + + while ( ! alarmed && (c = get_char()) >= 0) { + int n, abort_len, report_len; + + if (echo) + echo_stderr(c); + if (verbose && c == '\n') { + if (s == logged) + logf(""); /* blank line */ + else + logf("%0.*v", s - logged, logged); + logged = s + 1; + } + + *s++ = c; + + if (verbose && s >= logged + 80) { + logf("%0.*v", s - logged, logged); + logged = s; + } + + if (Verbose) { + if (c == '\n') + fputc( '\n', stderr ); + else if (c != '\r') + fprintf( stderr, "%s", character(c) ); + } + + if (!report_gathering) { + for (n = 0; n < n_reports; ++n) { + if ((report_string[n] != (char*) NULL) && + s - temp >= (report_len = strlen(report_string[n])) && + strncmp(s - report_len, report_string[n], report_len) == 0) { + time_t time_now = time ((time_t*) NULL); + struct tm* tm_now = localtime (&time_now); + + strftime (report_buffer, 20, "%b %d %H:%M:%S ", tm_now); + strcat (report_buffer, report_string[n]); + + report_string[n] = (char *) NULL; + report_gathering = 1; + break; + } + } + } + else { + if (!iscntrl (c)) { + int rep_len = strlen (report_buffer); + report_buffer[rep_len] = c; + report_buffer[rep_len + 1] = '\0'; + } + else { + report_gathering = 0; + fprintf (report_fp, "chat: %s\n", report_buffer); + } + } + + if (s - temp >= len && + c == string[len - 1] && + strncmp(s - len, string, len) == 0) { + if (verbose) { + if (s > logged) + logf("%0.*v", s - logged, logged); + logf(" -- got it\n"); + } + + alarm(0); + alarmed = 0; + return (1); + } + + for (n = 0; n < n_aborts; ++n) { + if (s - temp >= (abort_len = strlen(abort_string[n])) && + strncmp(s - abort_len, abort_string[n], abort_len) == 0) { + if (verbose) { + if (s > logged) + logf("%0.*v", s - logged, logged); + logf(" -- failed"); + } + + alarm(0); + alarmed = 0; + exit_code = n + 4; + strcpy(fail_reason = fail_buffer, abort_string[n]); + return (0); + } + } + + if (s >= end) { + if (logged < s - minlen) { + if (verbose) + logf("%0.*v", s - logged, logged); + logged = s; + } + s -= minlen; + memmove(temp, s, minlen); + logged = temp + (logged - s); + s = temp + minlen; + } + + if (alarmed && verbose) + logf("warning: alarm synchronization problem"); + } + + alarm(0); + + if (verbose && printed) { + if (alarmed) + logf(" -- read timed out"); + else + logf(" -- read failed: %m"); + } + + exit_code = 3; + alarmed = 0; + return (0); +} + +/* + * Gross kludge to handle Solaris versions >= 2.6 having usleep. + */ +#ifdef SOL2 +#include +#if MAXUID > 65536 /* then this is Solaris 2.6 or later */ +#undef NO_USLEEP +#endif +#endif /* SOL2 */ + +#ifdef NO_USLEEP +#include +#include + +/* + usleep -- support routine for 4.2BSD system call emulations + last edit: 29-Oct-1984 D A Gwyn + */ + +extern int select(); + +int +usleep( usec ) /* returns 0 if ok, else -1 */ + long usec; /* delay in microseconds */ +{ + static struct { /* `timeval' */ + long tv_sec; /* seconds */ + long tv_usec; /* microsecs */ + } delay; /* _select() timeout */ + + delay.tv_sec = usec / 1000000L; + delay.tv_usec = usec % 1000000L; + + return select(0, (long *)0, (long *)0, (long *)0, &delay); +} +#endif + +void +pack_array (array, end) + char **array; /* The address of the array of string pointers */ + int end; /* The index of the next free entry before CLR_ */ +{ + int i, j; + + for (i = 0; i < end; i++) { + if (array[i] == NULL) { + for (j = i+1; j < end; ++j) + if (array[j] != NULL) + array[i++] = array[j]; + for (; i < end; ++i) + array[i] = NULL; + break; + } + } +} + +/* + * vfmtmsg - format a message into a buffer. Like vsprintf except we + * also specify the length of the output buffer, and we handle the + * %m (error message) format. + * Doesn't do floating-point formats. + * Returns the number of chars put into buf. + */ +#define OUTCHAR(c) (buflen > 0? (--buflen, *buf++ = (c)): 0) + +int +vfmtmsg(buf, buflen, fmt, args) + char *buf; + int buflen; + const char *fmt; + va_list args; +{ + int c, i, n; + int width, prec, fillch; + int base, len, neg, quoted; + unsigned long val = 0; + char *str, *buf0; + const char *f; + unsigned char *p; + char num[32]; + static char hexchars[] = "0123456789abcdef"; + + buf0 = buf; + --buflen; + while (buflen > 0) { + for (f = fmt; *f != '%' && *f != 0; ++f) + ; + if (f > fmt) { + len = f - fmt; + if (len > buflen) + len = buflen; + memcpy(buf, fmt, len); + buf += len; + buflen -= len; + fmt = f; + } + if (*fmt == 0) + break; + c = *++fmt; + width = prec = 0; + fillch = ' '; + if (c == '0') { + fillch = '0'; + c = *++fmt; + } + if (c == '*') { + width = va_arg(args, int); + c = *++fmt; + } else { + while (isdigit(c)) { + width = width * 10 + c - '0'; + c = *++fmt; + } + } + if (c == '.') { + c = *++fmt; + if (c == '*') { + prec = va_arg(args, int); + c = *++fmt; + } else { + while (isdigit(c)) { + prec = prec * 10 + c - '0'; + c = *++fmt; + } + } + } + str = 0; + base = 0; + neg = 0; + ++fmt; + switch (c) { + case 'd': + i = va_arg(args, int); + if (i < 0) { + neg = 1; + val = -i; + } else + val = i; + base = 10; + break; + case 'o': + val = va_arg(args, unsigned int); + base = 8; + break; + case 'x': + val = va_arg(args, unsigned int); + base = 16; + break; + case 'p': + val = (unsigned long) va_arg(args, void *); + base = 16; + neg = 2; + break; + case 's': + str = va_arg(args, char *); + break; + case 'c': + num[0] = va_arg(args, int); + num[1] = 0; + str = num; + break; + case 'm': + str = strerror(errno); + break; + case 'v': /* "visible" string */ + case 'q': /* quoted string */ + quoted = c == 'q'; + p = va_arg(args, unsigned char *); + if (fillch == '0' && prec > 0) { + n = prec; + } else { + n = strlen((char *)p); + if (prec > 0 && prec < n) + n = prec; + } + while (n > 0 && buflen > 0) { + c = *p++; + --n; + if (!quoted && c >= 0x80) { + OUTCHAR('M'); + OUTCHAR('-'); + c -= 0x80; + } + if (quoted && (c == '"' || c == '\\')) + OUTCHAR('\\'); + if (c < 0x20 || (0x7f <= c && c < 0xa0)) { + if (quoted) { + OUTCHAR('\\'); + switch (c) { + case '\t': OUTCHAR('t'); break; + case '\n': OUTCHAR('n'); break; + case '\b': OUTCHAR('b'); break; + case '\f': OUTCHAR('f'); break; + default: + OUTCHAR('x'); + OUTCHAR(hexchars[c >> 4]); + OUTCHAR(hexchars[c & 0xf]); + } + } else { + if (c == '\t') + OUTCHAR(c); + else { + OUTCHAR('^'); + OUTCHAR(c ^ 0x40); + } + } + } else + OUTCHAR(c); + } + continue; + default: + *buf++ = '%'; + if (c != '%') + --fmt; /* so %z outputs %z etc. */ + --buflen; + continue; + } + if (base != 0) { + str = num + sizeof(num); + *--str = 0; + while (str > num + neg) { + *--str = hexchars[val % base]; + val = val / base; + if (--prec <= 0 && val == 0) + break; + } + switch (neg) { + case 1: + *--str = '-'; + break; + case 2: + *--str = 'x'; + *--str = '0'; + break; + } + len = num + sizeof(num) - 1 - str; + } else { + len = strlen(str); + if (prec > 0 && len > prec) + len = prec; + } + if (width > 0) { + if (width > buflen) + width = buflen; + if ((n = width - len) > 0) { + buflen -= n; + for (; n > 0; --n) + *buf++ = fillch; + } + } + if (len > buflen) + len = buflen; + memcpy(buf, str, len); + buf += len; + buflen -= len; + } + *buf = 0; + return buf - buf0; +} -- cgit v1.2.1