 |
Index for Section 8 |
|
 |
Alphabetical listing for C |
|
chat(8)
NAME
chat - Automated conversational script with a modem
SYNOPSIS
/usr/sbin/chat [options] script
DESCRIPTION
The chat 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 (pppd) and the remote's pppd process.
OPTIONS
-f chatfile
Reads the chat script from the chatfile. 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.
-t timeout
Sets the timeout for the expected string to be received. If the string
is not received within the time limit, 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 chat program to
terminate with a non-zero error code.
-v Requests that the chat script be executed in a verbose mode. The chat
program logs all text received from the modem and the output strings
that it sends to the syslog.
script
If the script is not specified in a file with the -f option then the
script is included as parameters to the chat program.
CHAT SCRIPT
The chat script defines the communications between the local system and a
remote system. 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:
ogin:-BREAK-ogin: ppp ssword: hello2u2
In the previous example, the chat program should expect the string "ogin:".
If it fails to receive a login prompt within the time interval allotted, it
sends a break sequence to the remote, and then expects the string "ogin:".
If the first "ogin:" is received, the break sequence is not generated.
Once it receives the login prompt, the chat program sends the string ppp,
then expects the prompt "ssword:". When it receives the prompt for the
password, it sends the password hello2u2.
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 escape sequence.
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.
To help correct for characters that might 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:".
A very simple script is as follows:
ogin: ppp ssword: hello2u2
In other words, expect ogin:, send ppp, expect ssword:, send hello2u2.
In actual practice, simple scripts are rare. At the vary least, you should
include sub-expect sequences should the original string not be received, as
in the following script:
ogin:--ogin: ppp ssword: hello2u2
The preceding script is a better script than the simple one used earlier.
This looks for the same login: prompt, but if one is not received, it sends
a single return sequence and looks for login: again. Should line noise
obscure the first login prompt, sending an empty line will usually generate
a login prompt again.
ABORT STRINGS
Many modems report the status of the call as a string. These strings may
be CONNECTED or NO CARRIER or BUSY. 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 BUSY while the next time it may receive NO
CARRIER.
These abort strings may be specified in the script using the ABORT
sequence. It is written in the script as in the following example:
ABORT BUSY ABORT 'NO CARRIER' '' ATZ OK ATDT5551212 CONNECT
This sequence expects nothing, then sends the string ATZ. The expected
response to this is the string OK. When it receives OK, it sends the
string ATDT5551212 to dial the telephone. The expected string is CONNECT.
If the string CONNECT is received, the remainder of the script is executed.
If the modem finds the telephone busy, it sends the string BUSY. This
causes the string to match the abort character sequence. The script then
fails because it found a match to the abort string. If it receives the
string NO CARRIER string, it aborts for the same reason. Either string may
be received. Either string terminates the chat script.
TIMEOUT
The initial timeout value is 45 seconds. This may be changed using the -t
timeout option.
To change the timeout value for the next expect string, the following
example may be used:
ATZ OK ATDT5551212 CONNECT TIMEOUT 10 ogin:--ogin: TIMEOUT 5 assword: hello2u2
This changes 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.
The timeout, once changed, remains in effect until it is changed again.
SENDING EOT
The special reply string of EOT 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.
The EOT sequence may be embedded into the send string using the sequence
^D.
GENERATING BREAK
The special reply string of BREAK causes 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.
The break sequence may be embedded into the send string using the \K escape
sequence.
ESCAPE SEQUENCES
The expect and reply strings may contain escape sequences. All of the
sequences are valid in the reply string. Many are legal in the expect.
Those which are not valid in the expect sequence are so indicated.
'' 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.
\b Represents a backspace character.
\c Suppresses the newline at the end of the reply string. This is the only
means of sending 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. (Not valid in expect.)
\d Delays for one second. The program uses sleep command, which will delay
to a maximum of one second. (Not valid in expect.)
\K Inserts a BREAK. (Not valid in expect.)
\n Sends a newline or linefeed character.
\N Sends a null character. The same sequence may be represented by \0.
(Not valid in expect.)
\p Pauses for a fraction of a second. The delay is 1/10th of a second.
(Not valid in expect.)
\q Suppresses writing the string to the syslog file. The string ?????? is
written to the log in its place. (Not valid in expect.)
\r Sends or expects a carriage return.
\s Represents a space character in the string. This may be used when it is
not desirable to quote the strings that contain spaces. The sequence
'HI TIM' and HI\sTIM are the same.
\t Sends or expects a tab character.
\\ Sends or expects a backslash character.
\ddd
Collapses the octal digits (ddd) into a single ASCII character and sends
that character. (Some characters are not valid in expect.)
^C Substitutes the sequence with the control character represented by C.
For example, the character DC1 (17) is shown as ^Q. (Some characters
are not valid in expect.)
RELATED INFORMATION
Commands: uucp(1), pppd(8), uucico(8).