![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ckuker.doc CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / lbin / kermit|
Return to ckuker.doc CVS log | Up to [Research Unix] / researchv10dc / lbin / kermit |
1.1 root 1:
2: UNIX KERMIT
3:
4: ********
5: This document is formatted as an ordinary, plain text ASCII disk file. Typeset
6: copies are available in the Kermit User Guide from Columbia University.
7: Changes should be made to CKUKER.MSS.
8: ********
9:
10: Program: Frank da Cruz, Bill Catchings, Jeff Damens, Columbia University;
11: Herm Fischer, Encino CA; contributions by many others.
12: Language: C
13: Documentation:
14: Frank da Cruz, Herm Fischer
15: Version: 4E(068)
16: Date: January 24, 1988
17:
18: C-Kermit is an implementation of Kermit, written modularly and transportably in
19: C. The protocol state transition table is written in wart, a (non-proprietary)
20: lex-like preprocessor for C. System-dependent primitive functions are isolated
21: into separately compiled modules so that the program should be easily portable
22: among Unix systems and also to non-Unix systems that have C compilers, such as
23: VAX/VMS, Data General AOS/VS, Apollo Aegis, the Apple Macintosh, and the Com-
24: modore Amiga. This document applies to Unix implementations of C-Kermit, and
25: in most ways also to the VMS, Data General, and other implementations.
26:
27:
28: Unix Kermit Capabilities At A Glance:
29:
30: Local operation: Yes
31: Remote operation: Yes
32: Login scripts: Yes (UUCP style)
33: Transfer text files: Yes
34: Transfer binary files: Yes
35: Wildcard send: Yes
36: File transfer interruption: Yes
37: Filename collision avoidance: Yes
38: Can time out: Yes
39: 8th-bit prefixing: Yes
40: Repeat count prefixing: Yes
41: Alternate block checks: Yes
42: Terminal emulation: Yes
43: Communication settings: Yes
44: Transmit BREAK: Yes (most versions)
45: Support for dialout modems: Yes
46: IBM mainframe communication: Yes
47: Transaction logging: Yes
48: Session logging: Yes
49: Debug logging: Yes
50: Packet logging: Yes
51: Act as server: Yes
52: Talk to server: Yes
53: Advanced server functions: Yes
54: Local file management: Yes
55: Command/Init files: Yes
56: UUCP and multiuser line locking: Yes
57: Long packets: Yes
58: Sliding Windows: No
59: File attributes packets: No
60: Command macros: No
61: Raw file transmit: No
62:
63: All numbers in the C-Kermit documentation are decimal unless noted otherwise.
64:
65: C-Kermit provides traditional Unix command line operation as well as inter-
66: active command prompting and execution. The command line options provide ac-
67: cess to a basic subset of C-Kermit's capabilities; the interactive command set
68: is far richer.
69:
70: On systems with dialout modems, C-Kermit's command file and login script
71: facilities provide a counterpart to UUCP for file transfer with non-UNIX
72: operating systems, including the use of scheduled (e.g. late night) unattended
73: operation.
74:
75:
76: 1.1. The Unix File System
77:
78: Consult your Unix manual for details about the file system under your version
79: of Unix. In general, Unix files have lowercase names, possibly containing one
80: or more dots or other special characters. Unix directories are tree-struc-
81: tured. Directory levels are separated by slash ("/") characters. For example,
82:
83: /usr/foo/bar
84:
85: denotes the file bar in the directory /usr/foo. Alphabetic case is significant
86: in Unix file and directory names, i.e. "a" is a different file (or directory)
87: from "A". Wildcard or "meta" characters allow groups of files to be specified.
88: "*" matches any string; "?" matches any single character.
89:
90: When C-Kermit is invoked with file arguments specified on the Unix command
91: line, the Unix shell (Bourne Shell, C-Shell, K-Shell, etc) expands the meta
92: characters itself, and in this case a wider variety is available. For example,
93:
94: kermit -s ~/ck[uvm]*.{upd,bwr}]
95:
96: is expanded by the Berkeley C-Shell into a list of all the files in the user's
97: home directory (~/) that start with the characters "ck", followed by a single
98: character "u", "v", or "m", followed by zero or more characters, followed by a
99: dot, followed by one of the strings "upd" or "bwr". Internally, the C-Kermit
100: program itself expands only the "*" and "?" meta characters.
101:
102: Unix files are linear (sequential) streams of 8-bit bytes. Text files consist
103: of 7-bit ASCII characters, with the high-order bit off (0), and lines separated
104: by the Unix newline character, which is linefeed (LF, ASCII 10). This distin-
105: guishes Unix text files from those on most other ASCII systems, in which lines
106: are separated by a carriage-return linefeed sequence (CRLF, ASCII 13, followed
107: by linefeed, ASCII 10). Binary files are likely to contain data in the high
108: bits of the file bytes, and have no particular line or record structure.
109:
110: When transferring files, C-Kermit will convert between upper and lower case
111: filenames and between LF and CRLF line terminators automatically, unless told
112: to do otherwise. When binary files must be transferred, the program must be
113: instructed not to perform LF/CRLF conversion (-i on the command line or "set
114: file type binary" interactively; see below).
115:
116:
117: 1.2. File Transfer
118:
119: If C-Kermit is in local mode, the screen (stdout) is continously updated to
120: show the progress of the file transer. A dot is printed for every four data
121: packets, other packets are shown by type:
122:
123: I Exchange Parameter Information
124: R Receive Initiate
125: S Send Initiate
126: F File Header
127: G Generic Server Command
128: C Remote Host Command
129: N Negative Acknowledgement (NAK)
130: E Fatal Error
131: T Indicates a timeout occurred
132: Q Indicates a damaged, undesired, or illegal packet was received
133: % Indicates a packet was retransmitted
134:
135: You may type certain "interrupt" commands during file transfer:
136:
137: Control-F: Interrupt the current File, and go on to the next (if any).
138: Control-B: Interrupt the entire Batch of files, terminate the transaction.
139: Control-R: Resend the current packet
140: Control-A: Display a status report for the current transaction.
141:
142: These interrupt characters differ from the ones used in other Kermit implemen-
143: tations to avoid conflict with commonly used Unix shell interrupt characters.
144: With Version 7, System III, and System V implementations of Unix, interrupt
145: commands must be preceeded by the 'connect' escape character (e.g. normally-\).
146: Ctrl-F and Ctrl-B are effective only during the transfer of data (D) packets,
147: and cannot be used to interrupt a transfer that has not yet reached that stage.
148:
149: CAUTION: If Control-F or Control-B is used to cancel an incoming file,
150: and a file of the same name previously existed, and the "file warning"
151: feature is not enabled, then the previous copy of the file will dis-
152: appear.
153:
154: EMERGENCY EXIT: When running Unix Kermit in remote mode, if you have started a
155: protocol operation (sending or receiving a file, server command wait, etc), you
156: will not be able to communicate with the terminal in the normal way. In par-
157: ticular, you cannot stop the protocol by typing the normal Unix interrupt
158: characters, since the terminal has been put in "raw mode". If you need to
159: regain control quickly -- for instance, because the protocol is stuck -- you
160: can type two Control-C's directly to the Unix Kermit program ("connect" first
161: if necessary):
162:
163: Control-C Control-C
164:
165: This will cause the program to exit and restore the terminal to normal.
166:
167:
168: 1.3. Command Line Operation
169:
170: The C-Kermit command line syntax conforms to the Proposed Syntax Standards for
171: Unix System Commands put forth by Kathy Hemenway and Helene Armitage of AT&T
172: Bell Laboratories in Unix/World, Vol.1, No.3, 1984. The rules that apply are:
173:
174: - Command names must be between 2 and 9 characters ("kermit" is 6).
175: - Command names must include lower case letters and digits only.
176: - An option name is a single character.
177: - Options are delimited by '-'.
178: - Options with no arguments may be grouped (bundled) behind one
179: delimiter.
180: - Option-arguments cannot be optional.
181: - Arguments immediately follow options, separated by whitespace.
182: - The order of options does not matter.
183: - '-' preceded and followed by whitespace means standard input.
184:
185: A group of bundled options may end with an option that has an argument.
186:
187: The following notation is used in command descriptions:
188:
189: fn A Unix file specification, possibly containing the "wildcard" charac-
190: ters `*' or `?' (`*' matches all character strings, `?' matches any
191: single character).
192:
193: fn1 A Unix file specification which may not contain `*' or `?'.
194:
195: rfn A remote file specification in the remote system's own syntax, which
196: may denote a single file or a group of files.
197:
198: rfn1 A remote file specification which should denote only a single file.
199:
200: n A decimal number between 0 and 94.
201:
202: c A decimal number between 0 and 127 representing the value of an ASCII
203: character.
204:
205: cc A decimal number between 0 and 31, or else exactly 127, representing
206: the value of an ASCII control character.
207:
208: [ ] Any field in square braces is optional.
209:
210: {x,y,z} Alternatives are listed in curly braces.
211:
212: C-Kermit command line options may specify any combination of actions and set-
213: tings. If C-Kermit is invoked with a command line that specifies no actions,
214: then it will issue a prompt and begin interactive dialog. Action options
215: specify either protocol transactions or terminal connection.
216:
217: -s fn Send the specified file or files. If fn contains wildcard (meta)
218: characters, the Unix shell expands it into a list. If fn is '-' then
219: kermit sends from standard input, which may come from a file:
220:
221: kermit -s - < foo.bar
222:
223: or a parallel process:
224:
225: ls -l | grep christin | kermit -s -
226:
227: You cannot use this mechanism to send terminal typein. If you want to
228: send a file whose actual name is "-" you can precede it with a path
229: name, as in
230:
231: kermit -s ./-
232:
233: -r Receive a file or files. Wait passively for files to arrive.
234:
235: -k Receive (passively) a file or files, sending them to standard output.
236: This option can be used in several ways:
237:
238: kermit -k
239: Displays the incoming files on your screen; to be used only in
240: "local mode" (see below).
241:
242: kermit -k > fn1
243: Sends the incoming file or files to the named file, fn1. If more
244: than one file arrives, all are concatenated together into the
245: single file fn1.
246:
247: kermit -k | command
248: Pipes the incoming data (single or multiple files) to the indicated
249: command, as in
250:
251: kermit -k | sort > sorted.stuff
252:
253: -a fn1 If you have specified a file transfer option, you may give an alternate
254: name for a single file with the -a ("as") option. For example,
255:
256: kermit -s foo -a bar
257:
258: sends the file foo telling the receiver that its name is bar. If more
259: than one file arrives or is sent, only the first file is affected by
260: the -a option:
261:
262: kermit -ra baz
263:
264: stores the first incoming file under the name baz.
265:
266: -x Begin server operation. May be used in either local or remote mode.
267:
268: Before proceeding, a few words about remote and local operation are necessary.
269: C-Kermit is "local" if it is running on PC or workstation that you are using
270: directly, or if it is running on a multiuser system and transferring files over
271: an external communication line -- not your job's controlling terminal or con-
272: sole. C-Kermit is remote if it is running on a multiuser system and transfer-
273: ring files over its own controlling terminal's communication line (normally
274: /dev/tty), connected to your PC or workstation.
275:
276: If you are running C-Kermit on a PC, it is normally used in local mode, with
277: the "back port" designated for file transfer and terminal connection. If you
278: are running C-Kermit on a multiuser (timesharing) system, it is in remote mode
279: unless you explicitly point it at an external line for file transfer or ter-
280: minal connection. The following command sets C-Kermit's "mode":
281:
282: -l dev Line -- Specify a terminal line to use for file transfer and terminal
283: connection, as in
284:
285: kermit -l /dev/ttyi5
286:
287: When an external line is being used, you will also need some additional options
288: for successful communication with the remote system:
289:
290: -b n Baud -- Specify the baud rate for the line given in the -l option, as
291: in
292:
293: kermit -l /dev/ttyi5 -b 9600
294:
295: This option should always be included with the -l option, since the
296: speed of an external line is not necessarily what you expect.
297:
298: -p x Parity -- e,o,m,s,n (even, odd, mark, space, or none). If parity is
299: other than none, then the 8th-bit prefixing mechanism will be used for
300: transferring 8-bit binary data, provided the opposite Kermit agrees.
301: The default parity is none.
302:
303: -t Specifies half duplex, line turnaround with XON as the handshake
304: character.
305:
306: The following commands may be used only with a C-Kermit which is local either
307: by default or else because the -l option has been specified.
308:
309: -g rfn Actively request a remote server to send the named file or files; rfn
310: is a file specification in the remote host's own syntax. If fn happens
311: to contain any special shell characters, like space, '*', '[', etc,
312: these must be quoted, as in
313:
314: kermit -g x\*.\?
315:
316: or
317:
318: kermit -g "profile exec"
319:
320: -f Send a 'finish' command to a remote server.
321:
322: -c Establish a terminal connection over the specified or default com-
323: munication line, before any protocol transaction takes place. Get back
324: to the local system by typing the escape character (normally
325: Control-Backslash) followed by the letter 'c'.
326:
327: -n Like -c, but after a protocol transaction takes place; -c and -n may
328: both be used in the same command. The use of -n and -c is illustrated
329: below.
330:
331: If the other Kermit is on a remote system, the -l and -b options should also be
332: included with the -r, -k, or -s options.
333:
334: Several other command-line options are provided:
335:
336: -i Specifies that files should be sent or received exactly "as is" with no
337: conversions. This option is necessary for transmitting binary files.
338: It may also be used in Unix-to-Unix transfers (it must be given to both
339: Unix Kermit programs), where it will improve performance by circumvent-
340: ing the normal text-file conversions, and will allow mixture of text
341: and binary files in a single file group.
342:
343: -w Write-Protect -- Avoid filename collisions for incoming files.
344:
345: -e n Extended packet length -- Specify that C-Kermit is allowed to receive
346: packets up to length n, where n may be between 10 and some large num-
347: ber, like 1000, depending on the system. The default maximum length
348: for received packets is 90. Packets longer than 94 will be used only
349: if the other Kermit supports, and agrees to use, the "long packet"
350: protocol extension.
351:
352: -q Quiet -- Suppress screen update during file transfer, for instance to
353: allow a file transfer to proceed in the background.
354:
355: -d Debug -- Record debugging information in the file debug.log in the cur-
356: rent directory. Use this option if you believe the program is mis-
357: behaving, and show the resulting log to your local Kermit maintainer.
358:
359: -h Help -- Display a brief synopsis of the command line options.
360:
361: The command line may contain no more than one protocol action option.
362:
363: Files are sent with their own names, except that lowercase letters are raised
364: to upper, pathnames are stripped off, certain special characters like (`~') and
365: (`#') are changed to `X', and if the file name begins with a period, an `X' is
366: inserted before it. Incoming files are stored under their own names except
367: that uppercase letters are lowered, and, if -w was specified, a "generation
368: number" is appended to the name if it has the same name as an existing file
369: which would otherwise be overwritten. If the -a option is included, then the
370: same rules apply to its argument. The file transfer display shows any trans-
371: formations performed upon filenames.
372:
373: During transmission, files are encoded as follows:
374:
375: - Control characters are converted to prefixed printables.
376:
377: - Sequences of repeated characters are collapsed via repeat counts, if
378: the other Kermit is also capable of repeated-character compression.
379:
380: - If parity is being used on the communication line, data characters
381: with the 8th (parity) bit on are specially prefixed, provided the
382: other Kermit is capable of 8th-bit prefixing; if not, 8-bit binary
383: files cannot be successfully transferred.
384:
385: - Conversion is done between Unix newlines and carriage-return-linefeed
386: sequences unless the -i option was specified.
387:
388:
389: Command Line Examples:
390:
391:
392: kermit -l /dev/ttyi5 -b 1200 -cn -r
393:
394: This command connects you to the system on the other end of ttyi5 at 1200 baud,
395: where you presumably log in and run Kermit with a 'send' command. After you
396: escape back, C-Kermit waits for a file (or files) to arrive. When the file
397: transfer is completed, you are reconnected to the remote system so that you can
398: logout.
399: kermit -l /dev/ttyi4 -b 1800 -cntp m -r -a foo
400:
401: This command is like the preceding one, except the remote system in this case
402: uses half duplex communication with mark parity. The first file that arrives
403: is stored under the name foo.
404:
405:
406: kermit -l /dev/ttyi6 -b 9600 -c | tek
407:
408: This example uses Kermit to connect your terminal to the system at the other
409: end of ttyi6. The C-Kermit terminal connection does not provide any particular
410: terminal emulation, so C-Kermit's standard i/o is piped through a
411: (hypothetical) program called tek, which performs (say) Tektronix emulation.
412:
413:
414: kermit -l /dev/ttyi6 -b 9600 -nf
415:
416: This command would be used to shut down a remote server and then connect to the
417: remote system, in order to log out or to make further use of it. The -n option
418: is invoked after -f (-c would have been invoked before).
419:
420:
421: kermit -l /dev/ttyi6 -b 9600 -qg foo.\* &
422:
423: This command causes C-Kermit to be invoked in the background, getting a group
424: of files from a remote server (note the quoting of the `*' character). No dis-
425: play occurs on the screen, and the keyboard is not sampled for interruption
426: commands. This allows other work to be done while file transfers proceed in
427: the background.
428:
429:
430: kermit -l /dev/ttyi6 -b 9600 -g foo.\* > foo.log < /dev/null &
431:
432: This command is like the previous one, except the file transfer display has
433: been redirected to the file foo.log. Standard input is also redirected, to
434: prevent C-Kermit from sampling it for interruption commands.
435:
436:
437: kermit -iwx
438:
439: This command starts up C-Kermit as a server. Files are transmitted with no
440: newline/carriage-return-linefeed conversion; the -i option is necessary for bi-
441: nary file transfer and recommended for Unix-to-Unix transfers. Incoming files
442: that have the same names as existing files are given new, unique names.
443:
444:
445: kermit -l /dev/ttyi6 -b 9600
446:
447: This command sets the communication line and speed. Since no action is
448: specified, C-Kermit issues a prompt and enters an interactive dialog with you.
449: Any settings given on the command line remain in force during the dialog, un-
450: less explicitly changed.
451:
452:
453: kermit
454:
455: This command starts up Kermit interactively with all default settings.
456:
457: The next example shows how Unix Kermit might be used to send an entire direc-
458: tory tree from one Unix system to another, using the tar program as Kermit's
459: standard input and output. On the orginating system, in this case the remote,
460: type (for instance):
461:
462:
463: tar cf - /usr/fdc | kermit -is -
464:
465: This causes tar to send the directory /usr/fdc (and all its files and all its
466: subdirectories and all their files...) to standard output instead of to a tape;
467: kermit receives this as standard input and sends it as a binary file. On the
468: receiving system, in this case the local one, type (for instance):
469:
470:
471: kermit -il /dev/ttyi5 -b 9600 -k | tar xf -
472:
473: Kermit receives the tar archive, and sends it via standard output to its own
474: copy of tar, which extracts from it a replica of the original directory tree.
475:
476: A final example shows how a Unix compression utility might be used to speed up
477: Kermit file transfers:
478:
479: compress file | kermit -is - (sender)
480: kermit -ik | uncompress (receiver)
481:
482:
483: Exit Status Codes:
484:
485: Unix Kermit returns an exit status of zero, except when a fatal error is en-
486: countered, where the exit status is set to one. With background operation
487: (e.g., `&' at end of invoking command line) driven by scripted interactive com-
488: mands (redirected standard input and/or take files), any failed interactive
489: command (such as failed dial or script attempt) causes the fatal error exit.
490:
491:
492: 1.4. Interactive Operation
493:
494: C-Kermit's interactive command prompt is "C-Kermit>". In response to this
495: prompt, you may type any valid interactive C-Kermit command. C-Kermit executes
496: the command and then prompts you for another command. The process continues
497: until you instruct the program to terminate.
498:
499: Commands begin with a keyword, normally an English verb, such as "send". You
500: may omit trailing characters from any keyword, so long as you specify suf-
501: ficient characters to distinguish it from any other keyword valid in that
502: field. Certain commonly-used keywords (such as "send", "receive", "connect")
503: also have special non-unique abbreviations ("s" for "send", "r" for "receive",
504: "c" for "connect").
505:
506: Certain characters have special functions during typein of interactive com-
507: mands:
508:
509: ? Question mark, typed at any point in a command, will produce a message
510: explaining what is possible or expected at that point. Depending on
511: the context, the message may be a brief phrase, a menu of keywords, or
512: a list of files.
513:
514: ESC (The Escape or Altmode key) -- Request completion of the current
515: keyword or filename, or insertion of a default value. The result will
516: be a beep if the requested operation fails.
517:
518: DEL (The Delete or Rubout key) -- Delete the previous character from the
519: command. You may also use BS (Backspace, Control-H) for this function.
520:
521: ^W (Control-W) -- Erase the rightmost word from the command line.
522:
523: ^U (Control-U) -- Erase the entire command.
524:
525: ^R (Control-R) -- Redisplay the current command.
526:
527: SP (Space) -- Delimits fields (keywords, filenames, numbers) within a com-
528: mand. HT (Horizontal Tab) may also be used for this purpose.
529:
530: CR (Carriage Return) -- Enters the command for execution. LF (Linefeed)
531: or FF (formfeed) may also be used for this purpose.
532:
533: \ (Backslash) -- Enter any of the above characters into the command,
534: literally. To enter a backslash, type two backslashes in a row (\\).
535: A backslash at the end of a command line causes the next line to be
536: treated as a continuation line; this is useful for readability in com-
537: mand files, especially in the 'script' command.
538:
539: ^Z (Control-Z) -- On systems (like Berkeley Unix, Ultrix) with job con-
540: trol, suspend Kermit, i.e. put it into the background in such a way
541: that it can be brought back into the foreground (e.g. with an 'fg'
542: shell command) with all its settings intact.
543:
544: You may type the editing characters (DEL, ^W, etc) repeatedly, to delete all
545: the way back to the prompt. No action will be performed until the command is
546: entered by typing carriage return, linefeed, or formfeed. If you make any mis-
547: takes, you will receive an informative error message and a new prompt -- make
548: liberal use of `?' and ESC to feel your way through the commands. One impor-
549: tant command is "help" -- you should use it the first time you run C-Kermit.
550:
551: A command line beginning with a percent sign "%" is ignored. Such lines may be
552: used to include illustrative commentary in Kermit command dialogs.
553:
554: Interactive C-Kermit accepts commands from files as well as from the keyboard.
555: When you start C-Kermit, the program looks for the file .kermrc in your home or
556: current directory (first it looks in the home directory, then in the current
557: one) and executes any commands it finds there. These commands must be in in-
558: teractive format, not Unix command-line format (the initialization file is not
559: processed if you invoke Kermit with command-line action arguments, such that it
560: does not enter interactive dialog). A "take" command is also provided for use
561: at any time during an interactive session, to allow interactive-format commands
562: to be executed from a file; command files may be nested to any reasonable
563: depth.
564:
565: Here is a brief list of C-Kermit interactive commands:
566: % Comment
567: ! Execute a Unix shell command, or start a shell.
568: bye Terminate and log out a remote Kermit server.
569: close Close a log file.
570: connect Establish a terminal connection to a remote system.
571: cwd Change Working Directory.
572: dial Dial a telephone number.
573: directory Display a directory listing.
574: echo Display arguments literally.
575: exit Exit from the program, closing any open files.
576: finish Instruct a remote Kermit server to exit, but not log out.
577: get Get files from a remote Kermit server.
578: help Display a help message for a given command.
579: log Open a log file -- debugging, packet, session, transaction.
580: quit Same as 'exit'.
581: receive Passively wait for files to arrive.
582: remote Issue file management commands to a remote Kermit server.
583: script Execute a login script with a remote system.
584: send Send files.
585: server Begin server operation.
586: set Set various parameters.
587: show Display values of 'set' parameters.
588: space Display current disk space usage.
589: statistics Display statistics about most recent transaction.
590: take Execute commands from a file.
591:
592: The 'set' parameters are:
593: block-check Level of packet error detection.
594: delay How long to wait before sending first packet.
595: duplex Specify which side echoes during 'connect'.
596: escape-character Prefix for "escape commands" during 'connect'.
597: file Set various file parameters.
598: flow-control Communication line full-duplex flow control.
599: handshake Communication line half-duplex turnaround character.
600: incomplete Disposition for incompletely received files.
601: line Communication line device name.
602: modem-dialer Type of modem-dialer on communication line.
603: parity Communication line character parity.
604: prompt The C-Kermit program's interactive command prompt.
605: receive Parameters for inbound packets.
606: retry Packet retransmission limit.
607: send Parameters for outbound packets.
608: speed Communication line speed.
609: terminal Terminal parameters.
610:
611: The 'remote' commands are:
612: cwd Change remote working directory.
613: delete Delete remote files.
614: directory Display a listing of remote file names.
615: help Request help from a remote server.
616: host A command to the remote host in its own command language.
617: space Display current disk space usage on remote system.
618: type Display a remote file on your screen.
619: who Display who's logged in, or get information about a user.
620:
621: Most of these commands are described adequately in the Kermit User Guide or the
622: Kermit book. Special aspects of certain Unix Kermit commands are described
623: below.
624:
625:
626: THE 'SEND' COMMAND
627:
628: Syntax: send fn - or - send fn1 rfn1
629:
630: Send the file or files denoted by fn to the other Kermit, which should be run-
631: ning as a server, or which should be given the 'receive' command. Each file is
632: sent under its own name (as described above, or as specified by the 'set file
633: names' command). If the second form of the 'send' command is used, i.e. with
634: fn1 denoting a single Unix file, rfn1 may be specified as a name to send it un-
635: der. The 'send' command may be abbreviated to 's', even though 's' is not a
636: unique abbreviation for a top-level C-Kermit command.
637:
638: The wildcard (meta) characters `*' and `?' are accepted in fn. If `?' is to be
639: included, it must be prefixed by `\' to override its normal function of provid-
640: ing help. `*' matches any string, `?' matches any single character. Other
641: notations for file groups, like `[a-z]og', are not available in interactive
642: commands (though of course they are available on the command line). When fn
643: contains `*' or `?' characters, there is a limit to the number of files that
644: can be matched, which varies from system to system. If you get the message
645: "Too many files match" then you'll have to make a more judicious selection. If
646: fn was of the form
647:
648: usr/longname/anotherlongname/*
649:
650: then C-Kermit's string space will fill up rapidly -- try doing a cwd (see
651: below) to the path in question and reissuing the command.
652:
653: Note -- C-Kermit sends only from the current or specified directory. It does
654: not traverse directory trees. If the source directory contains subdirectories,
655: they will be skipped. By the same token, C-Kermit does not create directories
656: when receiving files. If you have a need to do this, you can pipe tar through
657: C-Kermit, as shown in the example on page 3, or under System III/V Unix you can
658: use cpio.
659:
660: Another Note -- The 'send' command does not skip over "invisible" files that
661: match the file specification; Unix systems usually treat files whose names
662: start with a dot (like .login, .cshrc, and .kermrc) as invisible. Similarly
663: for "temporary" files whose names start with "#".
664:
665:
666: THE 'RECEIVE' COMMAND
667:
668: Syntax: receive - or - receive fn1
669:
670: Passively wait for files to arrive from the other Kermit, which must be given
671: the 'send' command -- the 'receive' command does not work in conjunction with a
672: server (use 'get' for that). If fn1 is specified, store the first incoming
673: file under that name. The 'receive' command may be abbreviated to 'r'.
674:
675:
676: THE 'GET' COMMAND:
677:
678: Syntax: get rfn
679:
680: or: get
681: rfn
682: fn1
683:
684: Request a remote Kermit server to send the named file or files. Since a remote
685: file specification (or list) might contain spaces, which normally delimit
686: fields of a C-Kermit command, an alternate form of the command is provided to
687: allow the inbound file to be given a new name: type 'get' alone on a line, and
688: you will be prompted separately for the remote and local file specifications,
689: for example
690:
691: C-Kermit>get
692: Remote file specification: profile exec
693: Local name to store it under: profile.exec
694:
695: As with 'receive', if more than one file arrives as a result of the 'get' com-
696: mand, only the first will be stored under the alternate name given by fn1; the
697: remaining files will be stored under their own names if possible. If a `?' is
698: to be included in the remote file specification, you must prefix it with `\' to
699: suppress its normal function of providing help.
700:
701: If you have started a multiline 'get' command, you may escape from its lower-
702: level prompts by typing a carriage return in response to the prompt, e.g.
703:
704: C-Kermit>get
705: Remote file specification: foo
706: Local name to store it under: (Type a carriage return here)
707: (cancelled)
708: C-Kermit>
709:
710:
711: THE 'SERVER' COMMAND:
712:
713: The 'server' command places C-Kermit in "server mode" on the currently selected
714: communication line. All further commands must arrive as valid Kermit packets
715: from the Kermit on the other end of the line. The Unix Kermit server can
716: respond to the following commands:
717:
718: Command Server Response
719: get Sends files
720: send Receives files
721: bye Attempts to log itself out
722: finish Exits to level from which it was invoked
723: remote directory Sends directory lising
724: remote delete Removes files
725: remote cwd Changes working directory
726: remote type Sends files to your screen
727: remote space Reports about its disk usage
728: remote who Shows who's logged in
729: remote host Executes a Unix shell command
730: remote help Lists these capabilities
731:
732: The Unix Kermit server cannot always respond properly to a BYE command. It
733: will attempt to do so using "kill()", but this will not work on all systems or
734: under all conditions because of the complicated process structures that can be
735: set up under Unix.
736:
737: If the Kermit server is directed at an external line (i.e. it is in "local
738: mode") then the console may be used for other work if you have 'set file dis-
739: play off'; normally the program expects the console to be used to observe file
740: transfers and enter status queries or interruption commands. The way to get
741: C-Kermit into background operation from interactive command level varies from
742: system to system (e.g. on Berkeley Unix you would halt the program with ^Z and
743: then use the C-Shell 'bg' command to continue it in the background). The more
744: common method is to invoke the program with the desired command line arguments,
745: including "-q", and with a terminating "&".
746:
747: When the Unix Kermit server is given a 'remote host' command, it executes it
748: using the shell invoked upon login, e.g. the Bourne shell or the Berkeley
749: C-Shell.
750:
751:
752: THE 'REMOTE', 'BYE', AND 'FINISH' COMMANDS:
753:
754: C-Kermit may itself request services from a remote Kermit server. In addition
755: to 'send' and 'get', the following commands may also be sent from C-Kermit to a
756: Kermit server:
757:
758: remote cwd [directory]
759: If the optional remote directory specification is included, you will be
760: prompted on a separate line for a password, which will not echo as you
761: type it. If the remote system does not require a password for this
762: operation, just type a carriage return.
763:
764: remote delete rfn delete remote file or files.
765: remote directory [rfn] directory listing of remote files.
766: remote host command command in remote host's own command language.
767: remote space disk usage report from remote host.
768: remote type [rfn] display remote file or files on the screen.
769: remote who [user] display information about who's logged in.
770: remote help display remote server's capabilities.
771:
772: bye and finish:
773: When connected to a remote Kermit server, these commands cause the
774: remote server to terminate; 'finish' returns it to Kermit or system
775: command level (depending on the implementation or how the program was
776: invoked); 'bye' also requests it to log itself out.
777:
778:
779: THE 'LOG' AND 'CLOSE' COMMANDS:
780:
781: Syntax: log {debugging, packets, session, transactions} [ fn1 ]
782:
783: C-Kermit's progress may be logged in various ways. The 'log' command opens a
784: log, the 'close' command closes it. In addition, all open logs are closed by
785: the 'exit' and 'quit' commands. A name may be specified for a log file; if the
786: name is omitted, the file is created with a default name as shown below.
787:
788: log debugging
789: This produces a voluminous log of the internal workings of C-Kermit, of use
790: to Kermit developers or maintainers in tracking down suspected bugs in the
791: C-Kermit program. Use of this feature dramatically slows down the Kermit
792: protocol. Default name: debug.log.
793:
794: log packets
795: This produces a record of all the packets that go in and out of the com-
796: munication port. This log is of use to Kermit maintainers who are tracking
797: down protocol problems in either C-Kermit or any Kermit that C-Kermit is
798: connected to. Default name: packet.log.
799:
800: log session
801: This log will contain a copy of everything you see on your screen during
802: the 'connect' command, except for local messages or interaction with local
803: escape commands. Default name: session.log.
804:
805: log transactions
806: The transaction log is a record of all the files that were sent or received
807: while transaction logging was in effect. It includes time stamps and
808: statistics, filename transformations, and records of any errors that may
809: have occurred. The transaction log allows you to have long unattended file
810: transfer sessions without fear of missing some vital screen message.
811: Default name: transact.log.
812:
813: The 'close' command explicitly closes a log, e.g. 'close debug'.
814:
815: Note: Debug and Transaction logs are a compile-time option; C-Kermit may be
816: compiled without these logs, in which case it will run faster, it will take up
817: less space on the disk, and the commands relating to them will not be present.
818:
819:
820: LOCAL FILE MANAGEMENT COMMANDS:
821:
822: Unix Kermit allows some degree of local file management from interactive com-
823: mand level:
824:
825: directory [fn]
826: Displays a listing of the names, modes, sizes, and dates of files matching
827: fn (which defaults to `*'). Equivalent to `ls -l'.
828:
829: cwd [directory-name]
830: Changes Kermit's working directory to the one given, or to the default
831: directory if the directory name is omitted. This command affects only the
832: Kermit process and any processes it may subsequently create.
833:
834: space
835: Display information about disk space and/or quota in the current directory
836: and device.
837:
838: ! [command]
839: The command is executed by the Unix shell. If no command is specified,
840: then an interactive shell is started; exiting from the shell, e.g. by
841: typing Control-D or 'exit', will return you to C-Kermit command level. Use
842: the `!' command to provide file management or other functions not ex-
843: plicitly provided by C-Kermit commands. The `!' command has certain
844: peculiarities:
845:
846: - C-Kermit attempts to use your preferred, customary (login) shell.
847: - At least one space must separate the '!' from the shell command.
848: - A 'cd' (change directory) command executed in this manner will
849: have no effect -- use the C-Kermit 'cwd' command instead.
850:
851:
852: THE 'SET' AND 'SHOW' COMMANDS:
853:
854: Since Kermit is designed to allow diverse systems to communicate, it is often
855: necessary to issue special instructions to allow the program to adapt to
856: peculiarities of the another system or the communication path. These instruc-
857: tions are accomplished by the 'set' command. The 'show' command may be used to
858: display current settings. Here is a brief synopsis of settings available in
859: the current release of C-Kermit:
860:
861: block-check {1, 2, 3}
862: Determines the level of per-packet error detection. "1" is a single-
863: character 6-bit checksum, folded to include the values of all bits from
864: each character. "2" is a 2-character, 12-bit checksum. "3" is a
865: 3-character, 16-bit cyclic redundancy check (CRC). The higher the block
866: check, the better the error detection and correction and the higher the
867: resulting overhead. Type 1 is most commonly used; it is supported by all
868: Kermit implementations, and it has proven adequate in most circumstances.
869: Types 2 or 3 would be used to advantage when transferring 8-bit binary
870: files over noisy lines.
871:
872: delay n
873: How many seconds to wait before sending the first packet after a 'send'
874: command. Used in remote mode to give you time to escape back to your local
875: Kermit and issue a 'receive' command. Normally 5 seconds.
876:
877: duplex {full, half}
878: For use during 'connect'. Specifies which side is doing the echoing;
879: 'full' means the other side, 'half' means C-Kermit must echo typein itself.
880:
881: escape-character cc
882: For use during 'connect' to get C-Kermit's attention. The escape character
883: acts as a prefix to an 'escape command', for instance to close the connec-
884: tion and return to C-Kermit or Unix command level. The normal escape
885: character is Control-Backslash (28). The escape character is also used in
886: System III/V implementations to prefix interrupt commands during file
887: transfers.
888:
889: file {display, names, type, warning}
890: Establish various file-related parameters:
891:
892: display {on, off}
893: Normally 'on'; when in local mode, display progress of file transfers
894: on the screen (stdout), and listen to the keyboard (stdin) for inter-
895: ruptions. If off (-q on command line) none of this is done, and the
896: file transfer may proceed in the background oblivious to any other work
897: concurrently done at the console terminal.
898:
899: names {converted, literal}
900: Normally converted, which means that outbound filenames have path
901: specifications stripped, lowercase letters raised to upper, tildes and
902: extra periods changed to X's, and an X inserted in front of any name
903: that starts with period. Incoming files have uppercase letters
904: lowered. Literal means that none of these conversions are done; there-
905: fore, any directory path appearing in a received file specification
906: must exist and be write-accessible. When literal naming is being used,
907: the sender should not use path names in the file specification unless
908: the same path exists on the target system and is writable.
909:
910: type {binary, text} [{7, 8}]
911: The file type is normally text, which means that conversion is done be-
912: tween Unix newline characters and the carriage-return/linefeed se-
913: quences required by the canonical Kermit file transmission format, and
914: in common use on non-Unix systems. Binary means to transmit file con-
915: tents without conversion. Binary (`-i' in command line notation) is
916: necessary for binary files, and desirable in all Unix-to-Unix trans-
917: actions to cut down on overhead.
918:
919: The optional trailing parameter tells the bytesize for file transfer.
920: It is 8 by default. If you specify 7, the high order bit will be
921: stripped from each byte of sent and received files. This is useful for
922: transferring text files that may have extraneous high order bits set in
923: their disk representation (e.g. Wordstar or similar word processor
924: files).
925:
926: warning {on, off}
927: Normally off, which means that incoming files will silently overwrite
928: existing files of the same name. When on (`-w' on command line) Kermit
929: will check if an arriving file would overwrite an existing file; if so,
930: it will construct a new name for the arriving file, of the form foo~n,
931: where foo is the name they share and n is a "generation number"; if foo
932: exists, then the new file will be called foo~1. If foo and foo~1 ex-
933: ist, the new file will be foo~2, and so on. If the new name would be
934: longer than the maximum length for a filename, then characters would be
935: deleted from the end first, for instance, thelongestname on a system
936: with a limit of 14 characters would become thelongestn~1.
937:
938: CAUTION: If Control-F or Control-B is used to cancel an incom-
939: ing file, and a file of the same name previously existed, and
940: the "file warning" feature is not enabled, then the previous
941: copy of the file will disappear.
942:
943: flow-control {none, xon/xoff}
944: Normally xon/xoff for full duplex flow control. Should be set to 'none' if
945: the other system cannot do xon/xoff flow control, or if you have issued a
946: 'set handshake' command. If set to xon/xoff, then handshake should be set
947: to none. This setting applies during both terminal connection and file
948: transfer. Warning: This command may have no effect on certain Unix sys-
949: tems, where Kermit puts the communication line into 'rawmode', and rawmode
950: precludes flow control.
951:
952: incomplete {discard, keep}
953: Disposition for incompletely received files. If an incoming file is inter-
954: rupted or an error occurs during transfer, the part that was received so
955: far is normally discarded. If you "set incomplete keep" then such file
956: fragments will be kept.
957:
958: handshake {xon, xoff, cr, lf, bell, esc, none}
959: Normally none. Otherwise, half-duplex communication line turnaround hand-
960: shaking is done, which means Unix Kermit will not reply to a packet until
961: it has received the indicated handshake character or has timed out waiting
962: for it; the handshake setting applies only during file transfer. If you
963: set handshake to other than none, then flow should be set to none.
964:
965: line [device-name]
966: The device name for the communication line to be used for file transfer and
967: terminal connection, e.g. /dev/ttyi3. If you specify a device name, Kermit
968: will be in local mode, and you should remember to issue any other necessary
969: 'set' commands, such as 'set speed'. If you omit the device name, Kermit
970: will revert to its default mode of operation. If you specify /dev/tty,
971: Kermit will enter remote mode (useful when logged in through the "back
972: port" of a system normally used as a local-mode workstation). When Unix
973: Kermit enters local mode, it attempts to synchronize with other programs
974: (like uucp) that use external communication lines so as to prevent two
975: programs using the same line at once; before attempting to lock the
976: specified line, it will close and unlock any external line that was
977: previously in use. The method used for locking is the "uucp lock file",
978: explained in more detail later.
979:
980: modem-dialer {direct, hayes, racalvadic, ventel, ...}
981: The type of modem dialer on the communication line. "Direct" indicates ei-
982: ther there is no dialout modem, or that if the line requires carrier detec-
983: tion to open, then 'set line' will hang waiting for an incoming call.
984: "Hayes", "Ventel", and the others indicate that 'set line' (or the -l
985: argument) will prepare for a subsequent 'dial' command for the given
986: dialer. Support for new dialers is added from time to time, so type 'set
987: modem ?' for a list of those supported in your copy of Kermit. See the
988: description of the 'dial' command
989:
990: parity {even, odd, mark, space, none}
991: Specify character parity for use in packets and terminal connection, nor-
992: mally none. If other than none, C-Kermit will seek to use the 8th-bit
993: prefixing mechanism for transferring 8-bit binary data, which can be used
994: successfully only if the other Kermit agrees; if not, 8-bit binary data
995: cannot be successfully transferred.
996:
997: prompt [string]
998: The given string will be substituted for "C-Kermit>" as this program's
999: prompt. If the string is omitted, the prompt will revert to "C-Kermit>".
1000: If the string is enclosed in doublequotes, the quotes will be stripped and
1001: any leading and trailing blanks will be retained.
1002:
1003: send parameter
1004: Establish parameters to use when sending packets. These will be in effect
1005: only for the initial packet sent, since the other Kermit may override these
1006: parameters during the protocol parameter exchange (unless noted below).
1007:
1008: end-of-packet cc
1009: Specifies the control character needed by the other Kermit to recognize
1010: the end of a packet. C-Kermit sends this character at the end of each
1011: packet. Normally 13 (carriage return), which most Kermit implemen-
1012: tations require. Other Kermits require no terminator at all, still
1013: others may require a different terminator, like linefeed (10).
1014:
1015: packet-length n
1016: Specify the maximum packet length to send. Normally 90. Shorter
1017: packet lengths can be useful on noisy lines, or with systems or front
1018: ends or networks that have small buffers. The shorter the packet, the
1019: higher the overhead, but the lower the chance of a packet being cor-
1020: rupted by noise, and the less time to retransmit corrupted packets.
1021: This command overrides the value requested by the other Kermit during
1022: protocol initiation unless the other Kermit requests a shorter length.
1023:
1024: pad-character cc
1025: Designate a character to send before each packet. Normally, none is
1026: sent. Outbound padding is sometimes necessary for communicating with
1027: slow half duplex systems that provide no other means of line turnaround
1028: control. It can also be used to send special characters to communica-
1029: tions equipment that needs to be put in "transparent" or "no echo"
1030: mode, when this can be accomplished in by feeding it a certain control
1031: character.
1032:
1033: padding n
1034: How many pad characters to send, normally 0.
1035:
1036: start-of-packet cc
1037: The normal Kermit packet prefix is Control-A (1); this command changes
1038: the prefix C-Kermit puts on outbound packets. The only reasons this
1039: should ever be changed would be: Some piece of equipment somewhere be-
1040: tween the two Kermit programs will not pass through a Control-A; or,
1041: some piece of of equipment similarly placed is echoing its input. In
1042: the latter case, the recipient of such an echo can change the packet
1043: prefix for outbound packets to be different from that of arriving pack-
1044: ets, so that the echoed packets will be ignored. The opposite Kermit
1045: must also be told to change the prefix for its inbound packets.
1046:
1047: timeout n
1048: Specifies the number of seconds you want the other Kermit to wait for a
1049: packet before timing it out and requesting retransmission.
1050:
1051: receive parameter
1052: Establish parameters to request the other Kermit to use when sending pack-
1053: ets.
1054:
1055: end-of-packet cc
1056: Requests the other Kermit to terminate its packets with the specified
1057: character.
1058:
1059: packet-length n
1060: Specify the maximum packet length to that you want the other Kermit to
1061: send, normally 90. If you specify a length of 95 or greater, then it
1062: will be used if the other Kermit supports, and agrees to use, the Ker-
1063: mit protocol extension for long packets. In this case, the maximum
1064: length depends upon the systems involved, but there would normally be
1065: no reason for packets to be more than about 1000 characters in length.
1066: The 'show parameters' command displays C-Kermit's current and maximum
1067: packet lengths.
1068:
1069: pad-character cc
1070: C-Kermit normally does not need to have incoming packets preceded with
1071: pad characters. This command allows C-Kermit to request the other Ker-
1072: mit to use cc as a pad character. Default cc is NUL, ASCII 0.
1073:
1074: padding n
1075: How many pad characters to ask for, normally 0.
1076:
1077: start-of-packet cc
1078: Change the prefix C-Kermit looks for on inbound packets to correspond
1079: with what the other Kermit is sending.
1080:
1081: timeout n
1082: Normally, each Kermit partner sets its packet timeout interval based on
1083: what the opposite Kermit requests. This command allows you to override
1084: the normal procedure and specify a timeout interval for Unix Kermit to
1085: use when waiting for packets from the other Kermit. If you specify 0,
1086: then no timeouts will occur, and Unix Kermit will wait forever for ex-
1087: pected packets to arrive.
1088:
1089: speed {0, 110, 150, 300, 600, 1200, 1800, 2400, 4800, 9600}
1090: The baud rate for the external communication line. This command cannot be
1091: used to change the speed of your own console terminal. Many Unix systems
1092: are set up in such a way that you must give this command after a 'set line'
1093: command before you can use the line. 'set baud' is a synomym for 'set
1094: speed'.
1095:
1096: terminal
1097: Used for specifying terminal parameters. Currently, 'bytesize' is the only
1098: parameter provided, and it can be set to 7 or 8. It's 7 by default.
1099:
1100:
1101: THE 'SHOW' COMMAND:
1102:
1103: Syntax: show {parameters, versions}
1104:
1105: The "show" command with the default argument of "parameters" displays the
1106: values of all the 'set' parameters described above. If you type "show
1107: versions", then C-Kermit will display the version numbers and dates of all its
1108: internal modules. You should use the "show versions" command to ascertain the
1109: vintage of your Kermit program before reporting problems to Kermit maintainers.
1110:
1111:
1112: THE 'STATISTICS' COMMAND:
1113:
1114: The statistics command displays information about the most recent Kermit
1115: protocol transaction, including file and communication line i/o, timing and ef-
1116: ficiency, as well as what encoding options were in effect (such as 8th-bit
1117: prefixing, repeat-count compression).
1118:
1119:
1120: THE 'TAKE' AND 'ECHO' COMMANDS:
1121:
1122: Syntax: take fn1
1123: echo [text to be echoed]
1124:
1125: The 'take' command instructs C-Kermit to execute commands from the named file.
1126: The file may contain any interactive C-Kermit commands, including 'take'; com-
1127: mand files may be nested to any reasonable depth, but it may not contain text
1128: to be sent to a remote system during the 'connect' command. This means that a
1129: command file like this:
1130:
1131: set line /dev/tty17
1132: set speed 9600
1133: connect
1134: login myuserid
1135: mypassword
1136: etc
1137:
1138: will not send "login myserid" or any of the following text to the remote sys-
1139: tem. To carry on a canned dialog, use the 'script' command, described later.
1140:
1141: The '%' command is useful for including comments in take-command files. It may
1142: only be used at the beginning of a line.
1143:
1144: The 'echo' command may be used within command files to issue greetings, an-
1145: nounce progress, ring the terminal bell, etc. The 'echo' command should not be
1146: confused with the Unix 'echo' command, which can be used to show how meta
1147: characters would be expanded. The Kermit echo command simply displays its text
1148: argument (almost) literally at the terminal; the argument may contain octal es-
1149: capes of the form "\ooo", where o is an octal digit (0-7), and there may be 1,
1150: 2, or 3 such digits, whose value specify an ASCII character, such as "\007" (or
1151: "\07" or just "\7") for beep, "\012" for newline, etc. Of course, each back-
1152: slash must be must be entered twice in order for it to be passed along to the
1153: echo command by the Kermit command parser.
1154:
1155: Take-command files are in exactly the same syntax as interactive commands.
1156: Note that this implies that if you want to include special characters like
1157: question mark or backslash that you would have to quote with backslash when
1158: typing interactive commands, you must quote these characters the same way in
1159: command files. Long lines may be continued by ending them with a single back-
1160: slash.
1161:
1162: Command files may be used in lieu of command macros, which have not been imple-
1163: mented in this version of C-Kermit. For instance, if you commonly connect to a
1164: system called 'B' that is connected to ttyh7 at 4800 baud, you could create a
1165: file called b containing the commands
1166:
1167: % C-Kermit command file to connect to System B thru /dev/ttyh7
1168: set line /dev/ttyh7
1169: set speed 4800
1170: % Beep and give message
1171: echo \\007Connecting to System B...
1172: connect
1173:
1174: and then simply type 'take b' (or 't b' since no other commands begin with the
1175: letter 't') whenever you wish to connect to system B. Note the comment lines
1176: and the beep inserted into the 'echo' command.
1177:
1178: For connecting to IBM mainframes, a number of 'set' commands are required;
1179: these, too, can be conveniently collected into a 'take' file like this one:
1180:
1181: % Sample C-Kermit command file to set up current line
1182: % for IBM mainframe communication
1183: %
1184: set parity mark
1185: set handshake xon
1186: set flow-control none
1187: set duplex half
1188:
1189: Note that no single command is available to wipe out all of these settings and
1190: return C-Kermit to its default startup state; to do that, you can either res-
1191: tart the program, or else make a command file that executes the necessary 'set'
1192: commands:
1193:
1194: % Sample C-Kermit command file to restore normal settings
1195: %
1196: set parity none
1197: set handshake none
1198: set flow-control xon/xoff
1199: set duplex full
1200:
1201: An implicit 'take' command is executed upon your .kermrc file when C-Kermit
1202: starts up, upon either interactive or command-line invocation. The .kermrc
1203: file should contain 'set' or other commands you want to be in effect at all
1204: times. For instance, you might want override the default action when incoming
1205: files have the same names as existing files -- in that case, put the command
1206:
1207: set file warning on
1208:
1209: in your .kermrc file. On some non-Unix systems that run C-Kermit, the in-
1210: itialization file might have a different name, such as kermit.ini.
1211:
1212: Errors encountered during execution of take files (such as failure to complete
1213: dial or script operations) cause termination of the current take file, popping
1214: to the level that invoked it (take file, interactive level, or the shell).
1215: When kermit is executed in the background, errors during execution of a take
1216: file are fatal.
1217:
1218: Under Unix, you may also use the shell's redirection mechanism to cause
1219: C-Kermit to execute commands from a file:
1220:
1221: kermit < cmdfile
1222:
1223: or you can even pipe commands in from another process:
1224:
1225: cmdprocess | kermit
1226:
1227:
1228: THE 'CONNECT' COMMAND:
1229:
1230: The 'connect' command ('c' is an acceptable non-unique abbreviation for
1231: 'connect') links your terminal to another computer as if it were a local ter-
1232: minal to that computer, through the device specified in the most recent 'set
1233: line' command, or through the default device if your system is a PC or worksta-
1234: tion. All characters you type at your keyboard are sent out the communication
1235: line (and if you have 'set duplex half', also displayed on your screen), and
1236: all characters arriving at the communication port are displayed on the screen.
1237: Current settings of speed, parity, duplex, and flow-control are honored, and
1238: the data connection is 7 bits wide unless you have given the command 'set ter-
1239: minal bytesize 8'. If you have issued a 'log session' command, everything you
1240: see on your screen will also be recorded to your session log. This provides a
1241: way to "capture" files from remote systems that don't have Kermit programs
1242: available.
1243:
1244: To get back to your own system, you must type the escape character, which is
1245: Control-Backslash (^\) unless you have changed it with the 'set escape' com-
1246: mand, followed by a single-character command, such as 'c' for "close
1247: connection". Single-character commands include:
1248:
1249: c Close the connection
1250: b Send a BREAK signal
1251: 0 (zero) send a null
1252: s Give a status report about the connection
1253: h Hangup the phone
1254: ^\ Send Control-Backslash itself (whatever you have defined the escape
1255: character to be, typed twice in a row sends one copy of it).
1256:
1257: Uppercase and control equivalents for (most of) these letters are also ac-
1258: cepted. A space typed after the escape character is ignored. Any other
1259: character will produce a beep.
1260:
1261: The connect command simply displays incoming characters on the screen. It is
1262: assumed any screen control sequences sent by the host will be handled by the
1263: firmware or emulation software in your terminal or PC. If special terminal
1264: emulation is desired, then the 'connect' command can invoked from the Unix com-
1265: mand line (-c or -n), piped through a terminal emulation filter, e.g.
1266:
1267: kermit -l /dev/acu -b 1200 -c | tek
1268:
1269:
1270: THE 'DIAL' COMMAND:
1271:
1272: Syntax: dial telephone-number-string
1273:
1274: This command controls dialout modems; you should have already issued a "set
1275: line" and "set speed" command to identify the terminal device, and a "set
1276: modem" command to identify the type of modem to be used for dialing. In the
1277: "dial" command, you supply the phone number and the Kermit program feeds it to
1278: the modem in the appropriate format and then interprets dialer return codes and
1279: modem signals to inform you whether the call was completed. The telephone-
1280: number-string may contain imbedded modem-dialer commands, such as comma for
1281: Hayes pause, or `&' for Ventel dialtone wait and `%' for Ventel pause (consult
1282: your modem manual for details).
1283:
1284: At the time of this writing, support is included for the following modems:
1285:
1286: - AT&T 7300 Internal Modem
1287: - Cermetek Info-Mate 212A
1288: - Concord Condor CDS 220
1289: - DEC DF03-AC
1290: - DEC DF100 Series
1291: - DEC DF200 Series
1292: - General DataComm 212A/ED
1293: - Hayes Smartmodem 1200 and compatibles
1294: - Penril
1295: - Racal Vadic
1296: - US Robotics 212A
1297: - Ventel
1298:
1299: Support for new modems is added to the program from time to time; you can check
1300: the current list by typing "set modem ?".
1301:
1302: The device used for dialing out is the one selected in the most recent "set
1303: line" command (or on a workstation, the default line if no "set line" command
1304: was given). The "dial" command calls locks the path (see the section on line
1305: locking below) and establishes a call on an exclusive basis. If it is desired
1306: to dial a call and then return to the shell (such as to do kermit activities
1307: depending on standard in/out redirection), it is necessary to place the dialed
1308: call under one device name (say, "/dev/cua0") and then escape to the shell
1309: within Kermit on a linked device which is separate from the dialed line (say,
1310: "/dev/cul0"). This is the same technique used by uucp (to allow locks to be
1311: placed separately for dialing and conversing).
1312:
1313: Because modem dialers have strict requirements to override the carrier-detect
1314: signal most Unix implementations expect, the sequence for dialing is more rigid
1315: than most other C-Kermit procedures.
1316:
1317: Example one:
1318:
1319: kermit -l /dev/cul0 -b 1200
1320: C-Kermit>set modem-dialer hayes hint: abbreviate set m h
1321: C-Kermit>dial 9,5551212
1322: Connected!
1323: C-Kermit>connect hint: abbreviate c
1324: logon, request remote server, etc.
1325: ^\c escape back
1326: C-Kermit> ...
1327: C-Kermit>quit hint: abbreviate q
1328:
1329: this disconnects modem, and unlocks line.
1330:
1331: Example two:
1332:
1333: kermit
1334: C-Kermit>set modem-dialer ventel
1335: C-Kermit>set line /dev/cul0
1336: C-Kermit>dial 9&5551212%
1337: Connected!
1338: C-Kermit> ...
1339:
1340: Example three:
1341:
1342: kermit
1343: C-Kermit>take my-dial-procedure
1344: Connected!
1345:
1346: file my-dial-procedure:
1347: set modem hayes
1348: set line /dev/tty99
1349: dial 5551212
1350: connect
1351:
1352: In general, C-Kermit requires that the modem provide the "carrier detect" (CD)
1353: signal when a call is in progress, and remove that signal when the call com-
1354: pletes or the line drops. If a modem switch setting is available to force CD,
1355: it should normally not be in that setting. C-Kermit also requires (on most
1356: systems) that the modem track the computer's "data terminal ready" (DTR) sig-
1357: nal. If a switch setting is available to simulate DTR asserted within the
1358: modem, then it should normally not be in that setting. Otherwise the modem
1359: will be unable to hang up at the end of a call or when interrupts are received
1360: by Kermit.
1361:
1362: For Hayes dialers, two important switch settings are #1 and #6. Switch #1
1363: should be normally be UP so that the modem can act according to your computer's
1364: DTR signal. But if your computer, or particular implementation of Kermit, can-
1365: not control DTR, then switch 1 should be DOWN. Switch #6 should normally be UP
1366: so carrier-detect functions properly (but put it DOWN if you have trouble with
1367: the UP position). Switches #2 (English versus digit result codes) and #4
1368: (Hayes echoes modem commands) may be in either position.
1369:
1370: If you want to interrupt a dial command in progress (for instance, because you
1371: just realize that you gave it the wrong number), type a Control-C to get back
1372: to command level.
1373:
1374:
1375: THE 'SCRIPT' COMMAND:
1376:
1377: Syntax: script expect send [expect send] . . .
1378:
1379: "expect" has the syntax: expect[-send-expect[-send-expect[...]]]
1380:
1381: The 'script' command carries on a "canned dialog" with a remote system, in
1382: which data is sent according to the remote system's responses. The typical use
1383: is for logging in to a remote system automatically.
1384:
1385: C-Kermit's script facility operates in a manner similar to that commonly used
1386: by the Unix UUCP system's "L.sys" file entries. A login script is a sequence
1387: of the form:
1388:
1389: expect send [expect send] . . .
1390:
1391: where expect is a prompt or message to be issued by the remote site, and send
1392: is the string (names, numbers, etc) to return, and expects are separated from
1393: sends by spaces. The send may also be the keyword EOT, to send Control-D, or
1394: BREAK, to send a break signal. Letters in sends may be prefixed by `~' to send
1395: special characters, including:
1396:
1397: ~b backspace
1398: ~s space
1399: ~q `?'(trapped by Kermit's command interpreter)
1400: ~n linefeed
1401: ~r carriage return
1402: ~t tab
1403: ~' single quote
1404: ~~ tilde
1405: ~" double quote
1406: ~x XON (Control-Q)
1407: ~c don't append a carriage return
1408: ~o[o[o]] an octal character
1409: ~d delay approx 1/3 second during send
1410: ~w[d[d]] wait specified interval during expect, then time out
1411:
1412: As with some UUCP systems, sent strings are followed by ~r unless they have a
1413: ~c.
1414:
1415: Only the last 7 characters in each expect are matched. A null expect, e.g. ~0
1416: or two adjacent dashes, causes a short delay before proceeding to the next send
1417: sequence. A null expect always succeeds.
1418:
1419: As with UUCP, if the expect string does not arrive, the script attempt fails.
1420: If you expect that a sequence might not arrive, as with UUCP, conditional se-
1421: quences may be expressed in the form:
1422:
1423: -send-expect[-send-expect[...]]
1424:
1425: where dashed sequences are followed as long as previous expects fail. Timeouts
1426: for expects can be specified using ~w; ~w with no arguments waits 15 seconds.
1427:
1428: Expect/send transactions can be easily be debugged by logging transactions.
1429: This records all exchanges, both expected and actual. The script execution
1430: will also be logged in the session log, if that is activated.
1431:
1432: Note that `\' characters in login scripts, as in any other C-Kermit interactive
1433: commands, must be doubled up. A line may be ended with a single `\' for con-
1434: tinuation.
1435:
1436: Example one:
1437:
1438: Using a modem, dial a UNIX host site. Expect "login" (...gin), and if it
1439: doesn't come, simply send a null string with a ~r. (Some Unixes require either
1440: an EOT or a BREAK instead of the null sequence, depending on the particular
1441: site's "logger" program.) After providing user id and password, respond "x" to
1442: a question-mark prompt, expect the Bourne shell "$" prompt (and send return if
1443: it doesn't arrive). Then cd to directory kermit, and run the program called
1444: "wermit", entering the interactive connect state after wermit is loaded.
1445:
1446: set modem ventel
1447: set line /dev/tty77
1448: set baud 1200
1449: dial 9&5551212
1450: script gin:--gin:--gin: smith ssword: mysecret ~q x $--$ \
1451: cd~skermit $ wermit
1452: connect
1453:
1454: Note that 'set line' is issued after 'set modem', but before 'set baud' or
1455: other line-related parameters.
1456:
1457: Example two:
1458:
1459: Using a modem, dial the Telenet network. This network expects three returns
1460: with slight delays between them. These are sent following null expects. The
1461: single return is here sent as a null string, with a return appended by default.
1462: Four returns are sent to be safe before looking for the prompt. Then the
1463: Telenet id and password are entered. Then Telenet is instructed to connect to
1464: a host site (c 12345). The host has a data switch that asks "which system";
1465: the script responds "myhost" (if the "which system" prompt doesn't appear, the
1466: Telenet connect command is reissued). The script waits for an "@" prompt from
1467: the host, then sends the user ID ("joe") and password ("secret"), looks for
1468: another "@" prompt, runs Kermit, and in response to the Kermit's prompt (which
1469: ends in ">"), gives the commands "set parity even" and "server". Files are
1470: then exchanged. The commands are in a take file; note the continuation of the
1471: 'script' command onto several lines using the `\' terminator.
1472:
1473: set modem hayes
1474: set line /dev/acu
1475: set speed 1200
1476: set parity mark
1477: dial 9,5551212
1478: script ~0 ~0 ~0 ~0 ~0 ~0 ~0 ~0 @--@--@ id~saa001122 = 002211 @ \
1479: c~s12345 ystem-c~s12345-ystem myhost @ joe~ssecret @ kermit \
1480: > set~sparity~seven > server
1481: send some.stuff
1482: get some.otherstuff
1483: bye
1484: quit
1485:
1486: Since these commands may be executed totally in the background, they can also
1487: be scheduled. A typical shell script, which might be scheduled by cron, would
1488: be as follows (csh used for this example):
1489:
1490: #
1491: #keep trying to dial and log onto remote host and exchange files
1492: #wait 10 minutes before retrying if dial or script fail.
1493: #
1494: cd someplace
1495: while ( 1 )
1496: kermit < /tonight.cmd >> nightly.log &
1497: if ( ! $status ) break
1498: sleep 600
1499: end
1500:
1501: File tonight.cmd might have two takes in it, for example, one to take a file
1502: with the set modem, set line, set baud, dial, and script, and a second take of
1503: a file with send/get commands for the remote server. The last lines of
1504: tonight.cmd should be a bye and a quit.
1505:
1506:
1507: THE 'HELP' COMMAND:
1508:
1509: Syntax: help
1510: or: help keyword
1511: or: help {set, remote} keyword
1512:
1513: Brief help messages or menus are always available at interactive command level
1514: by typing a question mark at any point. A slightly more verbose form of help
1515: is available through the 'help' command. The 'help' command with no arguments
1516: prints a brief summary of how to enter commands and how to get further help.
1517: 'help' may be followed by one of the top-level C-Kermit command keywords, such
1518: as 'send', to request information about a command. Commands such as 'set' and
1519: 'remote' have a further level of help. Thus you may type 'help', 'help set',
1520: or 'help set parity'; each will provide a successively more detailed level of
1521: help.
1522:
1523:
1524: THE 'EXIT' AND 'QUIT' COMMANDS:
1525:
1526: These two commands are identical. Both of them do the following:
1527:
1528: - Attempt to insure that the terminal is returned to normal.
1529: - Relinquish access to any communication line assigned via 'set line'.
1530: - Relinquish any uucp and multiuser locks on the communications line.
1531: - Hang up the modem, if the communications line supports data terminal
1532: ready.
1533: - Close any open logs or other files.
1534:
1535: After exit from C-Kermit, your default directory will be the same as when you
1536: started the program. The 'exit' command is issued implicitly whenever C-Kermit
1537: halts normally, e.g. after a command line invocation, or after certain kinds of
1538: interruptions.
1539:
1540:
1541: 1.5. UUCP Lock Files
1542:
1543: Unix has no standard way of obtaining exclusive access to an external com-
1544: munication line. When you issue the 'set line' command to Unix Kermit, Unix
1545: would normally grant you access to the line even if some other process is
1546: making use of it. The method adopted by most Unix systems to handle this
1547: situation is the "UUCP lock file". UUCP, the Unix-to-Unix Copy program,
1548: creates a file in its directory (usually /usr/spool/uucp, on some systems
1549: /etc/locks) with a name like LCK..name, where name is the device name, for in-
1550: stance tty07.
1551:
1552: Unix Kermit uses UUCP lock files in order to avoid conflicts with UUCP, tip, or
1553: other programs that follow this convention. Whenever you attempt to access an
1554: external line using the 'set line' command or `-l' on the command line, Kermit
1555: looks in the UUCP directory for a lock file corresponding to that device. For
1556: instance, if you 'set line /dev/ttyi6' then Kermit looks for the file
1557:
1558: /usr/spool/uucp/LCK..ttyi6
1559:
1560: If it finds this file, it gives you an error message and a directory listing of
1561: the file so that you can see who is using it, e.g.
1562:
1563: -r--r--r-- 1 fdc 4 May 7 13:02 /usr/spool/uucp/LCK..ttyi6
1564:
1565: In this case, you would look up user fdc to find out how soon the line will be-
1566: come free.
1567:
1568: This convention requires that the uucp directory be publicly readable and
1569: writable. If it is not, the program will issue an appropriate warning message,
1570: but will allow you to proceed at your own risk (and the risk of anyone else who
1571: might also be using the same line).
1572:
1573: If no lock file is found, Unix Kermit will attempt create one, thus preventing
1574: anyone who subsequently tries to run Kermit, UUCP, tip, or similar programs on
1575: the same line from gaining access until you release the line. If Kermit could
1576: not create the lock file (for instance because the uucp directory is write-
1577: protected), then you will receive a warning message but will be allowed to
1578: proceed at your -- and everyone else's -- risk. When Kermit terminates nor-
1579: mally, your lock file is removed.
1580:
1581: Even when the lock directory is writable and readable, the locking mechanism
1582: depends upon all users using the same name for the same device. If a device
1583: has more than one path associated with it, then a lock can be circumvented by
1584: using an alias.
1585:
1586: When a lock-creating program abruptly terminates, e.g. because it crashes or is
1587: killed via shell command, the lock file remains in the uucp directory,
1588: spuriously indicating that the line is in use. If the lock file is owned by
1589: yourself, you may remove it. Otherwise, you'll have to get the owner or the
1590: system manager to remove it, or else wait for a system task to do so; uucp sup-
1591: ports a function (uuclean) which removes these files after a predetermined age
1592: -- uucp sites tend to run this function periodically via crontab.
1593:
1594: Locking is not needed, or used, if communications occur over the user's login
1595: terminal line (normally /dev/tty).
1596:
1597: It may be seen that line locking is fraught with peril. It is included in Unix
1598: Kermit only because other Unix communication programs rely on it. While it is
1599: naturally desirable to assure exclusive access to a line, it is also un-
1600: desirable to refuse access to a vacant line only because of a spurious lock
1601: file, or because the uucp directory is not appropriately protected.
1602:
1603:
1604: 1.6. C-Kermit under Berkeley or System III/V Unix:
1605:
1606: C-Kermit may be interrupted at command level or during file transfer by typing
1607: Control-C. The program will perform its normal exit function, restoring the
1608: terminal and releasing any lock. If a protocol transaction was in progress, an
1609: error packet will be sent to the opposite Kermit so that it can terminate
1610: cleanly.
1611:
1612: C-Kermit may be invoked in the background ("&" on shell commmand line). If a
1613: background process is "killed", the user will have to manually remove any lock
1614: file and may need to restore the modem. This is because the kill signal
1615: (kill(x,9)) cannot be trapped by Kermit.
1616:
1617: During execution of a system command ('directory', 'cwd', or `!'), C-Kermit can
1618: often be returned to command level by typing a single Control-C. (With System
1619: III/V, the usual interrupt function (often the DEL key) is replaced by
1620: Control-C.)
1621:
1622: Under Berkeley Unix only: C-Kermit may also be interrupted by ^Z to put the
1623: process in the background. In this case the terminal is not restored. You
1624: will have to type Control-J followed by "reset" followed by another Control-J
1625: to get your terminal back to normal.
1626:
1627: Control-C, Control-Z, and Control-\ lose their normal functions during terminal
1628: connection and also during file transfer when the controlling tty line is being
1629: used for packet i/o.
1630:
1631: If you are running C-Kermit in "quiet mode" in the foreground, then interrupt-
1632: ing the program with a console interrupt like Control-C will not restore the
1633: terminal to normal conversational operation. This is because the system call
1634: to enable console interrupt traps will cause the program to block if it's run-
1635: ning in the background, and the primary reason for quiet mode is to allow the
1636: program to run in the background without blocking, so that you can do other
1637: work in the foreground.
1638:
1639: If C-Kermit is run in the background ("&" on shell commmand line), then the in-
1640: terrupt signal (Control-C) (and System III/V quit signal) are ignored. This
1641: prevents an interrupt signal intended for a foreground job (say a compilation)
1642: from being trapped by a background Kermit session.
1643:
1644:
1645: 1.7. C-Kermit on the DEC Pro-3xx with Pro/Venix Version 1
1646:
1647: The DEC Professional 300 series are PDP-11/23 based personal computers. Venix
1648: Version 1 is a Unix v7 derivative. It should not be confused with Venix Ver-
1649: sion 2, which is based on ATT System V; these comments apply to Venix Version 1
1650: only. C-Kermit runs in local mode on the Pro-3xx when invoked from the con-
1651: sole; the default device is /dev/com1.dout. When connected to a remote system
1652: (using C-Kermit's 'connect' command), Pro/Venix itself (not Kermit) provides
1653: VT52 terminal emulation. Terminal operation at high speeds (like 9600 baud)
1654: requires xon/xoff flow control, which unfortunately interferes with applica-
1655: tions such as the EMACS that use Control-Q and Control-S as commands.
1656:
1657: When logging in to a Pro-3xx (or any workstation) through the "back port", it
1658: may be necessary to give the command "set line /dev/tty" in order to get
1659: C-Kermit to function correctly in remote mode (on a system in which it normally
1660: expects to be operating in local mode).
1661:
1662:
1663: 1.8. C-Kermit under VAX/VMS
1664:
1665: C-Kermit can be built using VAX-11 C to run under VMS. Most of the descrip-
1666: tions in this manual hold true, but it should be noted that as of this writing
1667: the VMS support is not thoroughly tested, and no explicit support exists for
1668: the various types of VMS files and their attributes.
1669:
1670: The C-Kermit init file for VMS is called KERMIT.INI.
1671:
1672:
1673: 1.9. C-Kermit on the Macintosh and other Systems
1674:
1675: The "protocol kernel" of C-Kermit is also used by Columbia's Macintosh Kermit.
1676: The user and system interface is entirely different, and is covered in a
1677: separate document.
1678:
1679: There is also a Kermit for the Commodore Amiga based on C-Kermit, as well as
1680: versions for MS-DOS, Data General operating systems, etc.
1681:
1682:
1683: 1.10. C-Kermit Restrictions and Known Bugs
1684:
1685: 1. Editing characters: The program's interactive command interrupt,
1686: delete, and kill characters are Control-C, Delete (or Backspace),
1687: and Control-U, respectively. There is currently no way to change
1688: them to suit your taste or match those used by your shell, in case
1689: those are different.
1690:
1691: 2. Flow control: C-Kermit attempts to use XON/XOFF flow control during
1692: protocol operations, but it also puts the communication line into
1693: "rawmode". On many systems, rawmode disables flow control, so even
1694: though you may have "set flow xon/xoff", no flow control will be
1695: done. This is highly system and Unix-version dependent.
1696:
1697: 3. High baud rates: There's no way to specify baud rates higher than
1698: 9600 baud. Most Unix systems don't supply symbols for them (unless
1699: you use EXTA, EXTB), and even when they do, the program has no way
1700: of knowing whether a specific port's serial i/o controller supports
1701: those rates.
1702:
1703: 4. Modem controls: If a connection is made over a communication line
1704: (rather than on the controlling terminal line), and that line has
1705: modem controls, (e.g. data terminal ready and carrier detection
1706: implementation), returning to the shell level will disconnect the
1707: conversation. In that case, one should use interactive mode com-
1708: mands, and avoid use of piped shell-level operation (also see 'set
1709: modem-dialer' and 'dial' commands.)
1710:
1711: 5. Login Scripts: The present login scripts implementation follows the
1712: Unix conventions of uucp's "L.sys" file, rather than the normal Ker-
1713: mit "INPUT/OUTPUT" style.
1714:
1715: 6. Dial-out vs dial-in communications lines: C-Kermit requires a
1716: dial-out or dedicated line for the "set line" or "-l" options. Most
1717: systems have some lines dedicated to dial-in, which they enable
1718: "loggers" on, and some lines available for dial-out. Recent
1719: releases of Unix (ATT & Berkeley) have mechanisms for changing the
1720: directionality of a line.
1721:
1722: 7. Using C-Kermit on Local Area Networks: C-Kermit can successfully
1723: operate at speeds up to 9600 baud over LANs, provided the network
1724: buffers are big enough to accommodate Kermit packets.
1725:
1726: When computers are connected to LAN's through asynchronous terminal
1727: interfaces, then the connection should be configured to do XON/XOFF
1728: flow control between the network interface and the computer, rather
1729: than passing these signals through transparently. This can help
1730: prevent Kermit from overrunning the LAN's buffers if they are small
1731: (or if the LAN is congested), and will can also prevent the LAN from
1732: overrunning a slow Kermit's buffers.
1733:
1734: If the network hardware cannot accept 100 characters at a time, and
1735: flow control cannot be done between the network and the computer,
1736: then Kermit's "set send/receive packet-length" command can be used
1737: to shorten the packets.
1738:
1739: 8. Resetting terminal after abnormal termination or kill: When C-Kermit
1740: terminates abnormally (say, for example, by a kill command issued by
1741: the operator) the user may need to reset the terminal state. If
1742: commands do not seem to be accepted at the shell prompt, try
1743: Control-J "stty sane" Control-J (use "reset" on Berkeley Unix).
1744: That should take the terminal out of "raw mode" if it was stuck
1745: there.
1746:
1747: 9. Remote host commands may time-out on lengthy activity: Using
1748: "remote host" to instruct the C-Kermit server to invoke Unix func-
1749: tions (like "make") that might take a long time to produce output
1750: can cause timeout conditions.
1751:
1752: 10. XOFF deadlocks: When connecting back to C-Kermit after a trans-
1753: action, or after finishing the server, it may be necessary to type a
1754: Control-Q to clear up an XOFF deadlock. There's not much the
1755: program can do about this...
1756:
1757:
1758: 1.11. How to Build C-Kermit for a Unix System
1759:
1760: The C-Kermit files, as distributed from Columbia, all begin with the prefix
1761: "ck". You should make a directory for these files and then cd to it. A
1762: makefile is provided to build C-Kermit for various Unix systems (there are
1763: separate makefiles for VMS and the Macintosh). As distributed, the makefile
1764: has the name "ckuker.mak". You should rename it to "makefile" and then type
1765: "make xxx", where xxx is the symbol for your system, for instance "make bsd" to
1766: make C-Kermit for 4.x BSD Unix. The result will be a program called "wermit".
1767: You should test this to make sure it works; if it does, then you can rename it
1768: to "kermit" and install it for general use. See the makefile for a list of the
1769: systems supported and the corresponding "make" arguments.
1770:
1771:
1772: 1.12. Adapting C-Kermit to Other Systems
1773:
1774: C-Kermit is designed for portability. The level of portability is indicated in
1775: parentheses after the module name: "C" means any system that has a C compiler
1776: that conforms to the description in "The C Programming Language" by Kernighan &
1777: Ritchie (Prentice-Hall, 1978). "Cf" is like "C", but also requires "standard"
1778: features like printf and fprintf, argument passing via argv/argc, and so on, as
1779: described in Kernighan & Ritchie. "Unix" means the module should be useful un-
1780: der any Unix implementation; it requires features such as fork() and pipes.
1781: Anything else means that the module is particular to the indicated system.
1782: C-Kermit file names are of the form:
1783:
1784: ck<system><what>.<type>
1785:
1786: where the part before the dot is no more than 6 characters long, the part after
1787: the dot no more than 3 characters long, and:
1788:
1789: <type> is the file type:
1790:
1791: c: C language source
1792: h: Header file for C language source
1793: w: Wart preprocessor source, converted by Wart (or Lex) to a C program
1794: nr: Nroff/Troff text formatter source
1795: mss: Scribe text formatter source
1796: doc: Documentation
1797: hlp: Help text
1798: bld: Instructions for building the program
1799: bwr: A "beware" file - list of known bugs
1800: upd: Program update log
1801: mak: Makefile
1802:
1803: <system> is a single character to tell what system the file applies to:
1804:
1805: a: Descriptive material, documentation
1806: c: All systems with C compilers
1807: d: Data General
1808: h: Harris computers (reserved)
1809: i: Commodore Amiga (Intuition)
1810: m: Macintosh
1811: p: IBM PC, PC-DOS (reserved)
1812: u: Unix
1813: v: VAX/VMS
1814: w: Wart
1815:
1816: <what> is mnemonic (up to 3 characters) for what's in the file:
1817:
1818: aaa: A "read-me" file, like this one
1819: cmd: Command parsing
1820: con: Connect command
1821: deb: Debug/Transaction Log formats, Typedefs
1822: dia: Modem/Dialer control
1823: fio: System-depdendent File I/O
1824: fns: Protocol support functions
1825: fn2: More protocol support functions
1826: ker: General C-Kermit definitions, information, documentation
1827: mai: Main program
1828: pro: Protocol
1829: scr: Script command
1830: tio: System-dependent terminal i/o & control and interrupt handing
1831: usr: User interface
1832: us2: More user interface
1833: us3: Still more user interface
1834:
1835: Examples:
1836:
1837: ckufio.c File i/o for Unix
1838: ckmtio.c Terminal i/o for Macintosh
1839: ckuker.mss Scribe source for for Kermit User Guide chapter
1840: ckuker.nr Nroff source file for Unix C-Kermit man page
1841:
1842: The following material discusses each of the C-Kermit modules briefly.
1843:
1844: ckcmai.c, ckcker.h, ckcdeb.h (Cf):
1845: This is the main program. It contains declarations for global variables
1846: and a small amount of code to initialize some variables and invoke the com-
1847: mand parser. In its distributed form, it assumes that command line ar-
1848: guments are passed to it via argc and argv. Since this portion of code is
1849: only several lines long, it should be easy to replace for systems that have
1850: different styles of user interaction. The header files define symbols and
1851: macros used by the various modules of C-Kermit. ckcdeb.h is the only
1852: header file that is included by all the C-Kermit modules, so it contains
1853: not only the debug format definitions, but also any compiler-dependent
1854: typedefs.
1855:
1856: ckwart.c (Cf), ckcpro.w (C):
1857: The ckcpro module embodies the Kermit protocol state table and the code to
1858: accomplish state switching. It is written in "wart", a language which may
1859: be regarded as a subset of the Unix "lex" lexical analyzer generator. Wart
1860: implements enough of lex to allow the ckprot module to function. Lex it-
1861: self was not used because it is proprietary. The protocol module ckcpro.w
1862: is read by wart, and a system-independent C program is produced. The syn-
1863: tax of a Wart program is illustrated by ckcpro.w, and is described in
1864: ckwart.doc.
1865:
1866: ckcfns.c (C):
1867: The module contains all the Kermit protocol support functions -- packet
1868: formation, encoding, decoding, block check calculation, filename and data
1869: conversion, protocol parameter negotiation, and high-level interaction with
1870: the communication line and file system. To accommodate small systems, this
1871: module has been split into two -- ckcfns.c and ckcfn2.c.
1872:
1873: ckutio.c:
1874: This module contains the system-dependent primitives for communication line
1875: i/o, timers, and interrupts for the various versions of Unix. Certain im-
1876: portant variables are defined in this module, which determine whether
1877: C-Kermit is by default remote or local, what the default communication
1878: device is, and so forth. The tio module maintains its own private database
1879: of file descriptors and modes for the console terminal and the file trans-
1880: fer communication line so that other modules (like ckcfns or the terminal
1881: connect module) need not be concerned with them. The variations among Unix
1882: implementations with respect to terminal control and timers are accom-
1883: modated via conditional compilation.
1884:
1885: ckufio.c:
1886: This module contains system-dependent primitives for file i/o, wildcard
1887: (meta character) expansion, file existence and access checking, and system
1888: command execution for the various versions of Unix. It maintains an inter-
1889: nal database of i/o "channels" (file pointers in this case) for the files
1890: C-Kermit cares about -- the input file (the file which is being sent), the
1891: output file (the file being received), the various logs, the screen, and so
1892: forth. This module varies little among Unix implementations except for the
1893: wildcard expansion code; the directory structure of 4.2bsd Unix is dif-
1894: ferent from that of other Unix systems. Again, variation among Unix sys-
1895: tems is selected using conditional compilation.
1896:
1897: ckuusr.h, ckuusr.c, ckuus2.c, ckuus3.c (Unix):
1898: This is the "user interface" for C-Kermit. It includes the command parser,
1899: the screen output functions, and console input functions. The command par-
1900: ser comes in two pieces -- the traditional Unix command line decoder (which
1901: is quite small and compact), and the interactive keyword parser (which is
1902: rather large). This module is fully replacable; its interface to the other
1903: modules is very simple, and is explained at the beginning of the source
1904: file. The ckuusr module also includes code to execute any commands
1905: directly which don't require the Kermit protocol -- local file management,
1906: etc. The module is rated "Unix" because it makes occasional use of the
1907: system() function.
1908:
1909: Note that while ckuusr is logically one module, it has been split up into
1910: three C source files, plus a header file for the symbols they share in com-
1911: mon. This is to accommodate small systems that cannot handle big modules.
1912: ckuusr.c has the command line and top-level interactive command parser;
1913: ckuus2.c has the help command and strings; ckuus3 has the set and remote
1914: commands along with the logging, screen, and "interrupt" functions.
1915:
1916: ckucmd.c, ckucmd.h (Cf):
1917: This is an interactive command parsing package developed for C-Kermit. It
1918: is written portably enough to be usable on any system that has a C compiler
1919: that supports functions like printf. The file name parsing functions
1920: depend upon primitives defined in the fio module; if these primitives can-
1921: not be supplied for a certain system, then the filename parsing functions
1922: can be deleted, and the package will still be useful for parsing keywords,
1923: numbers, arbitrary text strings, and so forth. The style of interaction is
1924: the same as that found on the DECSYSTEM-20.
1925:
1926: ckucon.c (Unix):
1927: This is the connect module. As supplied, it should operate in any Unix en-
1928: vironment, or any C-based environment that provides the fork() function.
1929: The module requires access to global variables that specify line speed,
1930: parity, duplex, flow control, etc, and invokes functions from the tio
1931: module to accomplish the desired settings and input/output, and functions
1932: from the fio module to perform session logging. No terminal emulation is
1933: performed, but since standard i/o is used for the console, this may be
1934: piped through a terminal emulation filter. The ckucon function may be en-
1935: tirely replaced, so long as the global settings are honored by its replace-
1936: ment. PC implementations of C-Kermit may require the ck?con module to do
1937: screen control, escape sequence interpretation, etc, and may also wish to
1938: write special code to get the best possible performance.
1939:
1940: ckudia.c (Unix):
1941: This is the dialer module. As supplied, it handles Hayes, Ventel, Penril,
1942: Racal-Vadic, and several other modems.
1943:
1944: ckuscr.c (Unix):
1945: This is the login script module. As supplied, it handles uucp-style
1946: scripts.
1947:
1948: Moving C-Kermit to a new system entails:
1949:
1950: 1. Creating a new ck?tio module in C, assembler, or whatever language
1951: is most appropriate for system programming on the new system. If
1952: the system is Unix-like, then support may be added within the
1953: ckutio.c module itself using conditional compilation.
1954:
1955: 2. Creating a new ck?fio module, as above.
1956:
1957: 3. If the system is not Unix-like, then a new ckuusr module may be re-
1958: quired, as well as a different invocation of it from ckcmai.
1959:
1960: 4. If the distributed connect module doesn't work or performs poorly,
1961: then it may be replaced. For instance, interrupt-driven i/o may be
1962: required, especially if the system doesn't have forks.
1963:
1964: Those who favor a different style of user/program interaction from that
1965: provided in ckuusr.c may replace the entire module, for instance with one that
1966: provides a mouse/window/icon environment, a menu/function-key environment, etc.
1967:
1968: A few guidelines should be followed to maintain portability:
1969:
1970: - Keep variable and function names to 6 characters or less. Don't use
1971: identifiers that are distinguished from one another only by al-
1972: phabetic case.
1973:
1974: - Keep modules small. For instance, on a PDP-11 it is necessary to
1975: keep the code segment of each module below 8K in order to allow the
1976: segment mapping to occur which is necessary to run programs larger
1977: than 64K on a non-I-and-D-space machine.
1978:
1979: - Keep strings short; many compilers have restrictive maximum lengths;
1980: 128 is the smallest maximum string constant length we've encountered
1981: so far.
1982:
1983: - Keep (f,s)printf formats short. If these exceed some compiler de-
1984: pendent maximum (say, 128) memory will be overwritten and the program
1985: will probably core dump.
1986:
1987: - Do not introduce system dependencies into ckcpro.w or ckcfn*.c.
1988:
1989: - If a variable is a character, declare as CHAR, not int, to prevent
1990: the various sign extension and byte swapping foulups that occur when
1991: characters are placed in integer variables.
1992:
1993: - Remember that different systems may use different length words for
1994: different things. Don't assume an integer can be used as a pointer,
1995: etc.
1996:
1997: - Don't declare static functions; these can wreak havoc with systems
1998: that do segment mapping.
1999:
2000: - In conditional compilations expressions, use #ifdef and #ifndef and
2001: not #if, which is not supported by some compilers. Also, don't use
2002: any operators in these expressions; many compilers will fail to un-
2003: derstand expressions like #ifdef FOO | BAR. Also, don't put trailing
2004: tokens on #else's or #endif's (use /* comments */).
2005:
2006: - Don't define multiline macros.
2007:
2008: In general, remember that this program will have to be compilable by old com-
2009: pilers and runnable on small systems.
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.