1KERMIT(1)                   General Commands Manual                  KERMIT(1)
2
3
4

NAME

6       kermit - C‐Kermit 9.0: transport‐ and platform‐independent interactive
7       and scriptable communications software.
8
9              This document is intended to give the beginner sufficient infor‐
10              mation to make basic (if not advanced) use of C‐Kermit 9.0.
11              Although it might be rather long for a Unix manual page, it's
12              still far shorter than the C‐Kermit manual, which should be con‐
13              sulted for advanced topics such as customization, character‐
14              sets, scripting, etc. We also attempt to provide a clear struc‐
15              tural overview of C‐Kermit's many capabilities, functional
16              areas, states, and modes and their interrelation, that should be
17              helpful to beginners and veterans alike, as well as to those
18              upgrading to version 9.0 from earlier releases.
19
20       This document is also available as a Web page at:
21
22              http://www.columbia.edu/kermit/ckututor.html
23

DESCRIPTION

25       C‐Kermit is an all‐purpose communications software package from the
26       Kermit Project at Columbia University that:
27
28       ·    Is portable to many platforms, Unix and non‐Unix alike.
29       ·    Can make both serial and network connections.
30       ·    Can conduct interactive terminal sessions over its connection.
31       ·    Can transfer text or binary files over the same connection.
32       ·    Can convert character sets in the terminal session.
33       ·    Can convert character sets during text‐file file transfer.
34       ·    Is customizable in every aspect of its operation.
35
36       C‐Kermit is a modem program, a Telnet client, an Rlogin client, an FTP
37       client, an HTTP client, and on selected platforms, also an X.25 client.
38       It can make its own secure Internet connections using IETF‐approved
39       security methods including Kerberos IV, Kerberos V, SSL/TLS, and SRP
40       and it can also make SSH connections through your external SSH client
41       application. It can be the far‐end file‐transfer or client/server part‐
42       ner of your desktop Kermit client. It can also accept incoming dialed
43       and network connections.  It can even be installed as an Internet ser‐
44       vice on its own standard TCP socket, 1649 [RFC2839, RFC2840].
45
46       And perhaps most important, everything you can do "by hand" (interac‐
47       tively) with C‐Kermit, can be "scripted" (automated) using its built‐in
48       cross‐platform transport‐independent script programming language, which
49       happens to be identical to its interactive command language.
50
51       This manual page offers an overview of C‐Kermit 9.0 for Unix ("Unix" is
52       an operating system family that includes AIX, DG/UX, FreeBSD, HP‐UX,
53       IRIX, Linux, Mac OS X, NetBSD, OpenBSD, Open Server, Open Unix, QNX,
54       Solaris, SunOS, System V R3, System V R4, Tru64 Unix, Unixware, Xenix,
55       and many others). For thorough coverage, please consult the published
56       C‐Kermit manual and supplements (see DOCUMENTATION below). For further
57       information about C‐Kermit, Kermit software for other platforms, and
58       Kermit manuals, visit the Kermit Project website:
59
60         http://www.columbia.edu/kermit/
61
62       This is a longer‐than‐average manual page, and yet it barely scratches
63       the surface. Don't be daunted. C‐Kermit is a large and complex package,
64       evolving over decades of practice and experience, but that doesn't mean
65       it's hard to learn or use. Its most commonly used functions are
66       explained here with pointers to additional information elsewhere.
67

SYNOPSIS

69       kermit [ filename ] [ options ] [ {=,--,+} text ] ]
70
71       or:
72
73       kermit URL
74
75       If the first command‐line argument is the name of a file, interactive‐
76       mode commands are executed from the file. The '=' (or "--") argument
77       tells Kermit not to parse the remainder of the command line, but to
78       make the words following '=' available as \%1, \%2, ... \%9. The "+"
79       argument is like "=" but for use in "kerbang scripts" (explained
80       below). A second command‐line format allows the one and only argument
81       to be a Telnet, FTP, HTTP, or IKSD URL.
82
83       Order of execution:
84
85        1.    The command file (if any).
86
87        2.    The initialization file, if any, unless suppressed with -Y.
88
89        3.    The customization file (if it is executed by the initialization
90              file).
91
92        4.    The command‐line URL (if any, and if so, execution stops here).
93
94        5.    Command‐line options (if any).
95
96        6.    Interactive commands.
97
98       Some command‐line options can cause actions (such as -s to send a
99       file); others just set parameters. If any action options are included
100       on the command line, Kermit exits when finished unless also given the
101       -S ("stay") option. If no action options are given, no initialization
102       or command files contained an EXIT or QUIT command, and no fatal errors
103       occurred, Kermit issues its prompt and waits for you to type commands.
104
105              Bear in mind that C‐Kermit can be built with selected features
106              disabled, and also that certain features are not available on
107              all platforms. For example, C‐Kermit can't be built with TCP/IP
108              support on a platform that does not have TCP/IP header files and
109              libraries (and even if Kermit does include TCP/IP support, it
110              can't be used to make TCP/IP connections on a computer that does
111              not have a TCP/IP stack installed). If your version of C‐Kermit
112              lacks a feature mentioned here, use its SHOW FEATURES command to
113              see what might have been excluded.
114
115       C‐Kermit has three kinds of commands: regular single‐letter command‐
116       line options, extended‐format command‐line options, and interactive
117       commands.
118
119       Like most Unix commands, C‐Kermit can be be given options on the com‐
120       mand line. But C‐Kermit also can be used interactively by giving it
121       commands composed of words, which are more intuitive than cryptic com‐
122       mand‐line options, and more flexible too. In other words, you don't
123       have to use C‐Kermit's command‐line options, but they are available if
124       you want to. (By the same token, you don't have to use its interactive
125       commands either ‐‐ you can use either or both in any combination.)
126
127       C‐Kermit is generally installed in the PATH as "kermit", and therefore
128       is invoked by typing the word "kermit" (lowercase) at the shell prompt,
129       and then pressing the Return or Enter key. If you wish to include com‐
130       mand‐line options, put them after the word "kermit" but before pressing
131       Return or Enter, separated by spaces, for example:
132
133         $ kermit -s ckermit.tar.gz
134
135       ('$' is the shell prompt; "kermit -s ckermit.tar.gz" is what you type,
136       followed by Return or Enter.)
137

OPTIONS

139       Here is a list of C‐Kermit's single‐letter command‐line options, which
140       start with a single dash (-), in ASCII ("alphabetical") order. Alpha‐
141       betic case is significant (-A is not the same as -a).  Action options
142       are tagged "ACTION".
143
144       -0     (digit zero)  100% transparent Connect state for "in‐the‐middle"
145              operation: 8 bits, no parity, no escape character, everything
146              passes through.
147
148       -8     (digit eight)  Connection is 8‐bit clean (this is the default in
149              C‐Kermit 8.0 and later). Equivalent to the EIGHTBIT command,
150              which in turn is a shortcut for SET TERMINAL BYTESIZE 8, SET
151              COMMAND BYTESIZE 8, SET PARITY NONE.
152
153       -9 arg (digit nine)  Make a connection to an FTP server.  Equivalent to
154              the FTP OPEN command.  Argument: IP‐address‐or‐host‐
155              name[:optional‐TCP‐port].  NOTE: C‐Kermit also has a separate
156              FTP command‐line personality, with regular FTP‐like command‐line
157              syntax. More about this below.
158
159       -A     Kermit is to be started as an Internet service (IKSD) (only from
160              inetd.conf).
161
162       -B     Kermit is running in Batch or Background (no controlling termi‐
163              nal). To be used in case Kermit doesn't automatically sense its
164              background status.  Equivalent to the SET BACKGROUND ON command.
165
166       -C arg Interactive‐mode Commands to be executed.  Argument: Commands
167              separated by commas, list in doublequotes.
168
169       -D arg Delay before starting to send in Remote mode.  Equivalent to the
170              SET DELAY command.  Argument: Number of seconds.
171
172       -E     Exit automatically when connection closes. Equivalent to SET
173              EXIT ON-DISCONNECT ON.
174
175       -F arg Use an open TCP connection.  Argument: Numeric file descriptor
176              of open TCP connection.  Also see: -j, -J.
177
178       -G arg (ACTION) Get file(s) from server, send contents to standard out‐
179              put, which normally would be piped to another process.  Argu‐
180              ment: Remote file specification, in quotes if it contains
181              metacharacters.  Also see: -g, -k.
182
183       -H     Suppress program startup Herald and greeting.
184
185       -I     Tell Kermit it has a reliable connection, to force streaming to
186              be used where it normally would not be.  Equivalent to the SET
187              RELIABLE ON command.
188
189       -J arg (ACTION) "Be like Telnet." Like -j but implies -E.  Argument: IP
190              hostname/address optionally followed by service.  NOTE: C‐Kermit
191              also has a separate Telnet command‐line personality, with regu‐
192              lar Telnet‐like command‐line syntax. More about this below.
193
194       -L     Recursive directory descent for files in -s option.
195
196       -M arg My user name (for use with Telnet, Rlogin, FTP, etc).  Equiva‐
197              lent to the SET LOGIN USER command.  Argument: Username string.
198
199       -O     (ACTION) (Uppercase letter O) Be a server for One command only.
200              Also see: -x.
201
202       -P     Don't convert file (Path) names of transferred files.  Equiva‐
203              lent to SET FILE NAMES LITERAL.
204
205       -Q     Quick Kermit protocol settings. Equivalent to the FAST command.
206              This is the default in C‐Kermit 7.0 and later.
207
208       -R     Remote‐only (this just makes IF REMOTE true).
209
210       -S     Stay (enter command parser after action options).
211
212       -T     Force Text mode for file transfer; implies -V.  Equivalent to
213              SET TRANSFER MODE MANUAL, SET FILE TYPE TEXT.
214
215       -V     Disable automatic per‐file text/binary switching.  Equivalent to
216              SET TRANSFER MODE MANUAL.
217
218       -Y     Skip (don't execute) the initialization file.
219
220       -a arg As‐name for file(s) in -s, -r, or -g.  Argument: As‐name string
221              (alternative filename). When receiving files, this can be a
222              directory name.
223
224       -b arg Speed for serial device. Equivalent to SET SPEED.  Argument:
225              Numeric Bits per second for serial connections.
226
227       -c     (ACTION) Enter Connect state before transferring files.
228
229       -d     Create a debug.log file with detailed debugging information (a
230              second -d adds timestamps). Equivalent to LOG DEBUG but takes
231              effect sooner.
232
233       -e arg Maximum length for incoming Kermit file‐transfer packets. Equiv‐
234              alent to SET RECEIVE PACKET-LENGTH.  Argument: Length in bytes.
235
236       -f     (ACTION) Send a FINISH command to a Kermit server.
237
238       -g arg Get file(s) from a Kermit server.  Argument: File specification
239              on other computer, in quotes if it contains metacharacters.
240              Equivalent to GET. Also see: -a, -G, -r.
241
242       -h     (ACTION) Print Help text for single‐letter command‐line options
243              (pipe thru 'more' to prevent scrolling).
244
245       -i     Force binary (Image) mode for file transfer; implies -V. Equiva‐
246              lent to SET TRANSFER MODE MANUAL, SET FILE TYPE BINARY.
247
248       -j arg Make a TCP/IP connection.  Argument: IP host name/address and
249              optional service name or number. Equivalent to the TELNET com‐
250              mand.  Also see: -J, -F.
251
252       -k     (ACTION) Receive file(s) to standard output, which normally
253              would be piped to another process.  Also see: -r, -G.
254
255       -l arg (Lowercase letter L) Make a connection on the given serial com‐
256              munications device. Equivalent to the SET LINE (SET PORT) com‐
257              mand.  Argument: Serial device name, e.g. /dev/ttyS0.
258
259       -m arg Modem type for use with the -l device. Equivalent to the SET
260              MODEM TYPE command.  Argument: Modem name as in SET MODEM TYPE
261              command, e.g. "usrobotics".
262
263       -n     (ACTION) Enter Connect state after transferring files (histori‐
264              cal).
265
266       -p arg Parity. Equivalent to the SET PARITY command.  Argument: One of
267              the following: e(ven), o(dd), m(ark), n(one), s(pace).
268
269       -q     Quiet (suppress most messages). Equivalent to SET QUIET ON.
270
271       -r     (ACTION) Receive file(s). Equivalent to the RECEIVE command.
272              Argument: (none, but see -a)
273
274       -s arg Send file(s).  Argument: One or more local file specifications.
275              Equivalent to the SEND command.  Also see: -a.
276
277       -t     (Historical) Xon (Ctrl-Q) Turnaround character for half‐duplex
278              connections (used on serial linemode connections to old main‐
279              frames). Equivalent to SET DUPLEX HALF, SET HANDSHAKE XON.
280
281       -v arg Window size for Kermit protocol (ignored when streaming). Equiv‐
282              alanet to SET WINDOW-SIZE.  Argument: Number, 1 to 32.
283
284       -w     Incoming files Write over existing files. Equivalent to SET FILE
285              COLLISION OVERWRITE.
286
287       -x     (ACTION) Enter server mode. Equivalent to the SERVER command.
288              Also see: -O.
289
290       -y arg Alternative initialization file.  Argument: Filename.
291
292       -z     Force foreground behavior. To be used in case Kermit doesn't
293              automatically sense its foreground status.  Equivalent to the
294              SET BACKGROUND OFF command.
295
296       Extended command‐line options (necessary because single‐letter ones are
297       about used up) start with two dashes (--), with words rather than sin‐
298       gle letters as option names. If an extended option takes an argument,
299       it is separated from the option word by a colon (:). Extended options
300       include:
301
302
303        --bannerfile:filename
304              File to display upon startup or IKSD login.
305
306        --cdfile:filename
307              File to be sent for display to the client when server changes
308              directory (filename is relative to the changed‐to directory).
309
310        --cdmessage:{on,off}
311              Enable/disable the server CD message feature.
312
313        --help
314              Prints usage message for extended options.
315
316        --helpfile:filename
317              Designates a file containing custom text to replace the top‐
318              level HELP command.
319
320        --nointerrupts
321              Disables keyboard interrupts.
322
323        --noperms
324              Disables the Kermit protocol file Permissions attribute, to pre‐
325              vent transmission of file permissions (protection) from sender
326              to receiver.
327
328        --version
329              (ACTION) C‐Kermit prints its version number.
330
331       Plus several other IKSD‐Only options described at:
332
333         http://www.columbia.edu/kermit/iksd.html
334
335       See the file‐transfer section for examples of command‐line invocation.
336

COMMAND LANGUAGE

338       C‐Kermit's interactive command language is the subject of a 622‐page
339       book and another several hundred pages of updates, far too much for a
340       manual page. But it's not hard to get started. At the shell prompt,
341       just type "kermit" to get C‐Kermit's interactive command prompt:
342
343         $ kermit
344         (/current/directory) C-Kermit>
345
346       Begin by typing "help" (and then press the Return or Enter key) for a
347       top‐level overview, read it, and go from there. Your second command
348       should probably be "intro" (introduction). Note the prompt shows your
349       current directory (unless you tell Kermit to prompt you with something
350       else).
351
352       Interactive commands are composed mainly of regular English words, usu‐
353       ally in the form of imperative sentences, such as:
354
355         send oofa.txt
356
357       which tells Kermit to send (transfer) the file whose name is oofa.txt,
358       or:
359
360         set transfer mode automatic
361
362       which sets Kermit's "transfer mode" to "automatic" (whatever that
363       means).
364
365       While typing commands, you can abbreviate, ask for help (by pressing
366       the "?" key anywhere in a command), complete keywords or filenames
367       (with the Tab or Esc key), and edit your typing with Backspace or
368       Delete, Ctrl-W, Ctrl-U, etc. You can also recall previous commands,
369       save your command history, and who knows what else. Give the INTRO com‐
370       mand for details.
371
372       C‐Kermit has hundreds of commands, and they can be issued in infinite
373       variety and combinations, including commands for:
374
375       ·    Making connections (SET LINE, DIAL, TELNET, SSH, FTP, ...)
376       ·    Breaking connections (HANGUP, CLOSE)
377       ·    Transferring files (SEND, GET, RECEIVE, MOVE, RESEND, ...)
378       ·    Establishing preferences (SET)
379       ·    Displaying preferences (SHOW)
380       ·    Managing local files (CD, DELETE, MKDIR, DIR, RENAME, TYPE, ...)
381       ·    Managing remote files (RCD, RDEL, RMKDIR, RDIR, ...)
382       ·    Using local files (FOPEN, FCLOSE, FREAD, FWRITE)
383       ·    Programming (TAKE, DEFINE, IF, FOR, WHILE, SWITCH, DECLARE, ...)
384       ·    Interacting with the user (ECHO, ASK, ...)
385       ·    Interacting with a remote computer (INPUT, OUTPUT, ...)
386       ·    Interacting with local programs (RUN, EXEC, PTY, ...)
387       ·    Logging things (LOG SESSION, LOG PACKETS, LOG DEBUG, ...)
388
389       And of course QUIT or EXIT to get out and HELP to get help, and for
390       programmers: loops, decision making, variables, arrays, associative
391       arrays, integer and floating point arithmetic, macros, built‐in and
392       user‐defined functions, string manipulation, pattern matching, block
393       structure, scoping, recursion, and all the rest. To get a list of all
394       C‐Kermit's commands, type a question mark (?) at the prompt. To get a
395       description of any command, type HELP followed by the name of the com‐
396       mand, for example:
397
398         help send
399
400       The command interruption character is Ctrl-C (hold down the Ctrl key
401       and press the C key).
402
403       The command language "escape character", used to introduce variable
404       names, function invocations, and so on, is backslash (. If you need to
405       include a literal backslash in a command, type two of them, e.g.:
406
407         get c:\k95\k95custom.ini
408
409   Command Files, Macros, and Scripts
410       A file containing Kermit commands is called a Kermit command file or
411       Kermit script. It can be executed with Kermit's TAKE command:
412
413         (/current/dir) C-Kermit> take commandfile
414
415       (where "commandfile" is the name of the command file). Please don't
416       pipe a command file into Kermit's standard input (which might or might
417       not work); if you have Kermit commands in a file, tell Kermit to TAKE
418       the file.
419
420       In Unix only, a Kermit command file can also be executed directly by
421       including a "kerbang" line as the first line of the file:
422
423         #!/usr/local/bin/kermit +
424
425       That is, a top line that starts with "#!", followed immediately by the
426       full path of the Kermit executable, and then, if the Kermit script is
427       to be given arguments on the command line, a space and a plus sign. The
428       script file must also have execute permission:
429
430         chmod +x commandfile
431
432       Except for the " +" part, this is exactly the same as you would do for
433       a shell script, a Perl script, etc. Here's a simple but useless example
434       script that regurgitates its arguments (up to three of them):
435
436         #!/usr/local/bin/kermit +
437         if defined \%1 echo "Argument 1: \%1"
438         if defined \%2 echo "Argument 2: \%2"
439         if defined \%3 echo "Argument 3: \%3"
440         if defined \%4 echo "etc..."
441         exit
442
443       If this file is stored in your current directory as "commandfile",
444       then:
445
446         ./commandfile one two three four five
447
448       prints:
449
450         Argument 1: one
451         Argument 2: two
452         Argument 3: three
453         etc...
454
455       This illustrates the basic structure of a standalone Kermit script: the
456       "kerbang line", then some commands. It should end with "exit" unless
457       you want the Kermit prompt to appear when it is finished. \%1 is the
458       first argument, \%2 the second, and so on.
459
460       You can also create your own commands by defining named macros composed
461       of other Kermit commands (or macros). For example:
462
463         define mydelete {
464             local trash
465             assign trash \v(home)trashcan/
466             if not defined \%1 end 1 "Delete what?"
467             if wild \%1 {
468                 end 1 "Deleting multiple files is too scary"
469             }
470             if not exist \%1 end 1 "I can't find \%1"
471             if not directory \m(trash) {
472                 mkdir \m(trash)
473                 if fail end 1 "No trash can"
474             }
475             rename /list \%1 \m(trash)
476         }
477         define myundelete {
478             local trash
479             assign trash \v(home)trashcan/
480             if not defined \%1 end 1 "Undelete what?"
481             if wild \%1 {
482                 end 1 "Undeleting multiple files is too hard"
483             }
484             if not directory \m(trash) end 1 "No trash can"
485             if not exist \m(trash)\%1 {
486                 end 1 "I can't find \%1 in trash can"
487             }
488             rename /list \m(trash)\%1 .
489         }
490
491       These sample macros are not exactly production quality (they don't han‐
492       dle filenames that include path segments, they don't handle multiple
493       files, etc), but you get the idea: you can pass arguments to macros,
494       and they can check them and make other kinds of decisions. If you put
495       the above lines into your initialization or customization file
496       (explained below), you'll have MYDELETE and MYUNDELETE commands avail‐
497       able every time you start Kermit, at least as long as you don't sup‐
498       press execution of the initialization file. (Exercise for the reader:
499       Make these macros generally useful: remove limitations, add trashcan
500       display, browsing, emptying, etc.)
501
502       Kerbang scripts execute without the initialization file. This to keep
503       them portable and also to make them start faster. If you want to write
504       Kerbang scripts that depend on the initialization file, include the
505       command
506
507         take \v(home).kermrc
508
509       at the desired spot in the script. By the way, \v(xxx) is a built‐in
510       variable (xxx is the variable name, "home" in this case). To see what
511       built‐in variables are available, type "show variables" at the C‐Kermit
512       prompt. To see what else you can show, type "show ?". \m(xxx) is a user
513       defined variable (strictly speaking, it is a macro used as a variable).
514
515   Command List
516       C‐Kermit has more than 200 top‐level commands, and some of these, such
517       as SET, branch off into hundreds of subcommands of their own, so it's
518       not practical to describe them all here. Instead, here's a concise list
519       of the most commonly used top‐level commands, grouped by category. To
520       learn about each command, type "help" followed by the command name,
521       e.g. "help set".  Terms such as Command state and Connect state are
522       explained in subsequent sections.
523
524       Optional fields are shown in [ brackets ].  "filename" means the name
525       of a single file. filespec means a file specification that is allowed
526       to contain wildcard characters like '*' to match groups of files.
527       options are (optional) switches like /PAGE, /NOPAGE, /QUIET, etc,
528       listed in the HELP text for each command. Example:
529
530         send /recursive /larger:10000 /after:-1week /except:*.txt *
531
532       which can be read as "send all the files in this directory and all the
533       ones underneath it that are larger than 10000 bytes, no more than one
534       week old, and whose names don't end with ".txt".
535
536   Basic Commands
537              HELP   Requests top‐level help.
538
539              HELP command
540                     Requests help about the given command.
541
542              INTRODUCTION
543                     Requests a brief introduction to C‐Kermit.
544
545              LICENSE
546                     Displays the C‐Kermit software copyright and license.
547
548              VERSION
549                     Displays C‐Kermit's version number.
550
551              EXIT [ number ]
552                     Exits from Kermit with the given status code. Synonyms:
553                     QUIT, E, Q.
554
555              TAKE filename [ parameters... ]
556                     Executes commands from the given
557
558              LOG item [ filename ]
559                     Keeps a log of the given item in the given file.
560
561              [ DO ] macro [ parameters... ]
562                     Executes commands from the given macro.
563
564              SET parameter value
565                     Sets the given parameter to the given value.
566
567              SHOW category
568                     Shows settings in a given category.
569
570              STATUS Tells whether previous command succeeded or failed.
571
572              DATE [ date‐and/or‐time ]
573                     Shows current date‐time or interprets given date‐time.
574
575              RUN [ extern‐command [ parameters... ]
576                     Runs the given external command. Synonym: !.
577
578              EXEC [ extern‐command [ params... ]
579                     Kermit overlays itself with the given command.
580
581              SUSPEND
582                     Stops Kermit and puts it in the background. Synonym: Z.
583
584   Local File Management
585              TYPE [ options ] filename
586                     Displays the contents of the given file.
587
588              MORE [ options ] filename
589                     Equivalent to TYPE /PAGE (pause after each screenful).
590
591              CAT [ options ] filename
592                     Equivalent to TYPE /NOPAGE.
593
594              HEAD [ options ] filename
595                     Displays the first few lines of a given file.
596
597              TAIL [ options ] filename
598                     Displays the last few lines of a given file.
599
600              GREP [ options ] pattern filespec
601                     Displays lines from files that match the pattern. Syn‐
602                     onym: FIND.
603
604              DIRECTORY [ options ] [filespec ]
605                     Lists files (built‐in, many options).
606
607              LS [ options ] [ filespec ]
608                     Lists files (runs external "ls" command).
609
610              DELETE [ options ] [ filespec ]
611                     Deletes files. Synonym: RM.
612
613              PURGE [ options ] [ filespec ]
614                     Removes backup (*.~n~) files.
615
616              COPY [ options ] [ filespecs... ]
617                     Copies files. Synonym: CP.
618
619              RENAME [ options ] [ filespecs... ]
620                     Renames files. Synonym: MV.
621
622              CHMOD [ options ] [ filespecs... ]
623                     Changes permissions of files.
624
625              TRANSLATE filename charsets [ filename ]
626                     Converts file's character set. Synonym: XLATE.
627
628              CD     Changes your working directory to your home directory.
629
630              CD directory
631                     Changes your working directory to the one given.
632
633              CDUP   Changes your working directory one level up.
634
635              PWD    Displays your working directory.
636
637              BACK   Returns to your previous working directory.
638
639              MKDIR [ directory ]
640                     Creates a directory.
641
642              RMDIR [ directory ]
643                     Removes a directory.
644
645   Making Connections
646              SET LINE [ options ] devicename
647                     Opens the named serial port. Synonym: SET PORT.
648
649              OPEN LINE [ options ] devicename
650                     Same as SET LINE. Synonym: OPEN PORT.
651
652              SET MODEM TYPE [ name ]
653                     Tells Kermit what kind of modem is on the port.
654
655              DIAL [ number ]
656                     Tells Kermit to dial the given phone number with the
657                     modem.
658
659              REDIAL Redials the most recently dialed phone number.
660
661              ANSWER Waits for and answers an incoming call on the modem.
662
663              AUTHENTICATE [ parameters... ]
664                     Performs secure authentication on a TCP/IP connection.
665
666              SET NETWORK TYPE { TCP/IP, X.25, ... }
667                     Selects network type for subsequent SET HOST commands.
668
669              SET HOST [ options ] host [ port ]
670                     Opens a network connection to the given host and port.
671
672              SET HOST * port
673                     Waits for an incoming TCP/IP connection on the given
674                     port.
675
676              TELNET [ options ] host
677                     Opens a Telnet connection to the host and enters Connect
678                     state.
679
680              RLOGIN [ options ] host
681                     Opens an Rlogin connection to the host and enters Connect
682                     state.
683
684              IKSD [ options ] host
685                     Opens a connection to an Internet Kermit Service.
686
687              SSH [ options ] host
688                     Opens an SSH connection to the host and enters Connect
689                     state.
690
691              FTP OPEN host [ options ]
692                     Opens an FTP connection to the host.
693
694              HTTP [ options ] OPEN host
695                     Opens an HTTP connection to the host.
696
697              PTY external‐command
698                     Runs the command on a pseudoterminal as if it were a con‐
699                     nection.
700
701              PIPE external‐command
702                     Runs the command through a pipe as if it were a connec‐
703                     tion.
704
705   Using Connections
706              CONNECT [ options ]
707                     Enters Connect (terminal) state.  Synonym: C.
708
709              REDIRECT command
710                     Redirects the given external command over the connection.
711
712              TELOPT command
713                     Sends a Telnet protocol command (Telnet connections
714                     only).
715
716              Ctrl-\C
717                     "Escapes back" from Connect state to Command state.
718
719              Ctrl-\B
720                     (In Connect state) Sends a BREAK signal (serial or Tel‐
721                     net).
722
723              Ctrl-\!
724                     (In Connect state) Enters inferior shell; "exit" to
725                     return.
726
727              Ctrl-\?
728                     (In Connect state) Shows a menu of other escape‐level
729                     options.
730
731              Ctrl-\Ctrl-\
732                     (In Connect state) Type two Ctrl-Backslashes to send one
733                     of them.
734
735              SET ESCAPE [ character ]
736                     Changes Kermit's Connect‐state escape character.
737
738   Closing Connections
739              HANGUP Hangs up the currently open serial‐port or network con‐
740                     nection.
741
742              CLOSE  Closes the currently open serial‐port or network connec‐
743                     tion.
744
745              SET LINE (with no devicename)
746                     Closes the currently open serial‐port or network connec‐
747                     tion.
748
749              SET HOST (with no hostname)
750                     Closes the currently open serial‐port or network connec‐
751                     tion.
752
753              FTP CLOSE
754                     Closes the currently open FTP connection.
755
756              HTTP CLOSE
757                     Closes the currently open HTTP connection.
758
759              EXIT   Also closes all connections. Synonym: QUIT.
760
761              SET EXIT WARNING OFF
762                     Suppresses warning about open connections on exit or
763                     close.
764
765   File Transfer
766              SEND [ options ] filename [ as‐name ]
767                     Sends the given file. Synonym: S.
768
769              SEND [ options ] filespec
770                     Sends all files that match.
771
772              RESEND [ options ] filespec
773                     Resumes an interrupted SEND from the point of failure.
774
775              RECEIVE [ options ] [ as‐name ]
776                     Waits passively for files to arrive. Synonym: R.
777
778              LOG TRANSACTIONS [ filename ]
779                     Keeps a record of file transfers.
780
781              FAST   Use fast file‐transfer settings (default).
782
783              CAUTIOUS
784                     Use cautious and less fast file‐transfer settings.
785
786              ROBUST Use ultra‐conservative and slow file‐transfer settings.
787
788              STATISTICS [ options ]
789                     Gives statistics about the most recent file transfer.
790
791              WHERE  After transfer: "Where did my files go?".
792
793              TRANSMIT [ options ] [ofilename ]
794                     Sends file without protocol. Synonym: XMIT.
795
796              LOG SESSION [ filename ]
797                     Captures remote text or files without protocol.
798
799              SET PROTOCOL [ name... ]
800                     Tells Kermit to use an external file‐transfer protocol.
801
802              FTP { PUT, MPUT, GET, MGET, ... }
803                     FTP client commands.
804
805              HTTP { PUT, GET, HEAD, POST, ... }
806                     HTTP client commands.
807
808   Kermit Server
809              ENABLE, DISABLE
810                     Controls which server features can be used by clients.
811
812              SET SERVER
813                     Sets parameters prior to entering Server state.
814
815              SERVER Enters Server state.
816
817   Client of Kermit or FTP Server
818              [ REMOTE ] LOGIN [ user password ]
819                     Logs in to a Kermit server or IKSD that requires it.
820
821              [ REMOTE ] LOGOUT
822                     Logs out from a Kermit server or IKSD.
823
824              SEND [ options ] filename [ as‐name ]
825                     Sends the given file to the server. Synonyms: S, PUT.
826
827              SEND [ options ] filespec
828                     Sends all files that match.
829
830              RESEND [ options ] filespec
831                     Resumes an interrupted SEND from the point of failure.
832
833              GET [ options ] remote‐filespec
834                     Asks the server to send the given files. Synonym: G.
835
836              REGET [ options ] remote‐filespec
837                     Resumes an interrupted GET from the point of failure.
838
839              REMOTE CD [ directory ]
840                     Asks server to change its working directory. Synonym:
841                     RCD.
842
843              REMOTE PWD [ directory ]
844                     Asks server to display its working directory. Synonym:
845                     RPWD.
846
847              REMOTE DIRECTORY [ filespec... ]
848                     Asks server to send a directory listing. Synonym: RDIR.
849
850              REMOTE DELETE [ filespec... ]
851                     Asks server to delete files. Synonym: RDEL.
852
853              REMOTE [ command... ]
854                     (Many other commands: "remote ?" for a list).
855
856              MAIL [ options ] filespec
857                     Sends file(s) to be delivered as e‐mail (Kermit only).
858
859              FINISH Asks the server to exit server state (Kermit only).
860
861              BYE    Asks the server to log out and close the connection.
862
863   Script Programming
864              DEFINE, DECLARE, UNDEFINE, UNDECLARE, ASSIGN, EVALUATE, SEXPRES‐
865              SION, ARRAY, SORT, INPUT, OUTPUT, IF, FOR, WHILE, SWITCH, GOTO,
866              ECHO, ASK, GETC, GETOK, ASSERT, WAIT, SLEEP, FOPEN, FREAD,
867              FWRITE, FCLOSE, STOP, END, RETURN, LEARN, SHIFT, TRACE, VOID,
868              INCREMENT, DECREMENT, ... For these and many more you'll need to
869              consult the manual and supplements, and/or visit the Kermit
870              Script Library, which also includes a brief tutorial. Hint: HELP
871              LEARN to find out how to get Kermit to write simple scripts for
872              you.
873
874       Many of Kermit's commands have synonyms, variants, relatives, and so
875       on.  For example, MSEND is a version of SEND that accepts a list of
876       file specifications to be sent, rather than just one file specifica‐
877       tion, and MPUT is a synonym of MSEND. MOVE means to SEND and then
878       DELETE the source file if successful. MMOVE is like MOVE, but accepts a
879       list of filespecs, and so on. These are described in the full documen‐
880       tation.
881
882       Use question mark to feel your way through an unfamiliar command, as in
883       this example:
884
885         C-Kermit> remote ? One of the following:
886          assign     directory  kermit     print      rmdir
887          cd         exit       login      pwd        set
888          copy       help       logout     query      space
889          delete     host       mkdir      rename     type
890         C-Kermit> remote set ? One of the following:
891          attributes   file         retry        transfer
892          block-check  receive      server       window
893         C-Kermit> remote set file ? One of the following:
894          character-set  incomplete     record-length
895          collision      names          type
896         C-Kermit> remote set file names ? One of the following:
897          converted  literal
898         C-Kermit> remote set file names literal
899         C-Kermit>
900
901       This is called menu on demand: you get a menu when you want one, but
902       menus are not forced on you even when know what you're doing. Note that
903       you can also abbreviate most keywords, and you can complete them with
904       the Tab or Esc key. Also note that ? works for filenames too, and that
905       you can use it in the middle of a keyword or filename, not just at the
906       beginning. For example, "send x?" lists all the files in the current
907       directory whose names start with 'x'.
908

INITIALIZATION FILE

910       In its default configuration, C‐Kermit executes commands from a file
911       called .kermrc in your home directory when it starts, unless it is
912       given the -Y or -y command‐line option. Custom configurations might
913       substitute a shared system‐wide initialization file. The SHOW FILE com‐
914       mand tells what initialization file, if any, was used. The standard
915       initialization file "chains" to an individual customization file, .myk‐
916       ermc, in the home directory, in which each user can establish her/his
917       own preferences, define macros, and so on.
918
919       Since execution of the initialization file (at least the standard one)
920       makes C‐Kermit take longer to start, it might be better not to have an
921       initialization file, especially now that Kermit's default startup con‐
922       figuration is well attuned to modern computing and networking ‐‐ in
923       other words, you no longer have do anything special to make Kermit
924       transfers go fast. So instead of having an initialization file that is
925       executed every time Kermit starts, you might consider making one or
926       more kerbang scripts (with names other that .kermrc) that do NOT
927       include an "exit" command, and invoke those when you need the settings,
928       macro definitions, and/or scripted actions they contain, and invoke C‐
929       Kermit directly when you don't.
930
931       To put it another way... We still distribute the standard initializa‐
932       tion file since it's featured in the manual and backwards compatibility
933       is important to us. But there's no harm in not using it if you don't
934       need the stuff that's in it (services directory, dialing directory,
935       network directory, and associated macro definitions). On the other
936       hand, if there are settings or macros you want in effect EVERY time you
937       use Kermit, the initialization file (or the customization file it
938       chains to) is the place to put them, because that's the only place Ker‐
939       mit looks for them automatically each time you start it.
940

MODES OF OPERATION

942       Kermit is said to be in Local mode if it has made a connection to
943       another computer, e.g. by dialing it or establishing a Telnet connec‐
944       tion to it. The other computer is remote, so if you start another copy
945       of Kermit on the remote computer, it is said to be in Remote mode (as
946       long as it has not made any connections of its own). The local Kermit
947       communicates over the communications device or network connection, act‐
948       ing as a conduit between the the remote computer and your keyboard and
949       screen. The remote Kermit is the file‐transfer partner to the local
950       Kermit and communicates only through its standard input and output.
951
952       At any moment, a Kermit program can be in any of the following states.
953       It's important to know what they are and how to change from one to the
954       other.
955
956       Command state
957              In this state, Kermit reads commands from:
958
959              ·    Your keyboard; or:
960              ·    A file, or:
961              ·    A macro definition.
962
963              You can exit from Command state back to Unix with the EXIT or
964              QUIT command (same thing). You can enter Connect state with any
965              of various commands (CONNECT, DIAL, TELNET, etc). You can enter
966              file transfer state with commands like SEND, RECEIVE, and GET.
967              You can enter Server state with the SERVER command. The TAKE
968              command tells Kermit to read and execute commands from a file.
969              The (perhaps implied) DO command tells Kermit to read and exe‐
970              cute commands from a macro definition.  While in Command state,
971              you can interrupt any command, macro, or command file by typing
972              Ctrl-C (hold down the Ctrl key and press the C key); this nor‐
973              mally brings you back to the prompt.
974
975       Shell state
976              You can invoke an inferior shell or external command from the
977              Kermit command prompt by using the PUSH, RUN (!), EDIT, or
978              BROWSE command.  While the inferior shell or command is active,
979              Kermit is suspended and does nothing. Return to Kermit Command
980              state by exiting from the inferior shell or application.
981
982       Connect state
983              In this state, which can be entered only when in Local mode
984              (i.e. when Kermit has made a connection to another computer),
985              Kermit is acting as a terminal to the remote computer. Your key‐
986              strokes are sent to the remote computer and characters that
987              arrive over the communication connection are displayed on your
988              screen. This state is entered when you give a CONNECT, DIAL,
989              TELNET, RLOGIN, or IKSD command. You can return to command state
990              by logging out of the remote computer, or by typing:
991
992                Ctrl-\c
993
994              That is: Hold down the Ctrl key and press the backslash key,
995              then let go of the Ctrl key and press the C key. This is called
996              escaping back.  Certain other escape‐level commands are also
997              provided; type Ctrl-\?  for a list. For example, you can enter
998              Shell state with:
999
1000                Ctrl-\!
1001
1002              To send a Ctrl-\ to the host while in Connect state, type two of
1003              them in a row. See HELP CONNECT and HELP SET ESCAPE for more
1004              info.
1005
1006       Local file‐transfer state
1007              In this state, Kermit is sending packets back and forth with the
1008              other computer in order to transfer a file or accomplish some
1009              other file‐related task. And at the same time, it is displaying
1010              its progress on your screen and watching your keyboard for
1011              interruptions. In this state, the following single‐keystroke
1012              commands are accepted:
1013
1014
1015              X      Interrupt the current file and go on to the next (if
1016                     any).
1017
1018              Z      Interrupt the current file and skip all the rest.
1019
1020              E      Like Z but uses a "stronger" protocol (use if X or Z
1021                     don't work).
1022
1023              Ctrl-C Interrupt file‐transfer mode (use if Z or E don't work).
1024
1025       Kermit returns to its previous state (Command or Connect) when the
1026       transfer is complete or when interrupted successfully by X, Z, E, or
1027       Ctrl-C (hold down the Ctrl key and press the C key).
1028
1029       Remote file‐transfer state
1030              In this state, Kermit is exchanging file‐transfer packets with
1031              its local partner over its standard i/o. It leaves this state
1032              automatically when the transfer is complete. In case you find
1033              your local Kermit in Connect state and the remote one in File‐
1034              transfer state (in which it seems to ignore your keystrokes),
1035              you can usually return it to command state by typing three
1036              Ctrl-C's in a row. If that doesn't work, return your local Ker‐
1037              mit to Command state (Ctrl-\ C) and type "e‐packet" and then
1038              press the Return or Enter key; this forces a fatal Kermit proto‐
1039              col error.
1040
1041       Remote Server state
1042              This is like Remote File‐transfer state, except it never returns
1043              automatically to Command state. Rather, it awaits further
1044              instructions from the client program; that is, from your Local
1045              Kermit program. You can return the Remote Server to its previous
1046              state by issuing a "finish" command to the client, or if you are
1047              in Connect state, by typing three Ctrl-C's in a row. You can
1048              tell the server job to log out and break the connection by issu‐
1049              ing a "bye" command to the client.
1050
1051       Local Server state
1052              Like Remote‐Server state, but in local mode, and therefore with
1053              its file‐transfer display showing, and listening for single‐key
1054              commands, as in Local File‐transfer state. Usually this state is
1055              entered automatically when a remote Kermit program gives a GET
1056              command.
1057
1058              C‐Kermit, Kermit 95, and MS‐DOS Kermit all can switch automati‐
1059              cally from Connect state to Local File‐transfer state when you
1060              initiate a file transfer from the remote computer by starting
1061              Kermit and telling it to send or get a file, in which case, Con‐
1062              nect state is automatically resumed after the file transfer is
1063              finished.
1064
1065              Note that C‐Kermit is not a terminal emulator. It is a communi‐
1066              cations application that you run in a terminal window (e.g. con‐
1067              sole or Xterm). The specific emulation, such as VT100, VT220,
1068              Linux Console, or Xterm, is provided by the terminal window in
1069              which you are running C‐Kermit. Kermit 95 and MS‐DOS Kermit, on
1070              the other hand, are true terminal emulators. Why is C‐Kermit not
1071              a terminal emulator? CLICK HERE to read about it.
1072

MAKING CONNECTIONS

1074       Here is how to make different kinds of connections using interactive
1075       Kermit commands (as noted above, you can also make connections with
1076       command‐line options). Note that you don't have to make connections
1077       with Kermit. It can also be used on the far end of a connection as the
1078       remote file transfer and management partner of your local communica‐
1079       tions software.
1080
1081       Making a Telnet Connection
1082              At the C‐Kermit command prompt, simply type:
1083
1084                telnet foo.bar.com
1085
1086              (substituting desired hostname or address).  You can also
1087              include a port number:
1088
1089                telnet xyzcorp.com 3000 ;
1090
1091              If the connection is successful, Kermit automically enters Con‐
1092              nect state. When you logout from the remote host, Kermit auto‐
1093              matically returns to its prompt. More info: HELP TELNET, HELP
1094              SET TELNET, HELP SET TELOPT. Also see the IKSD section below.
1095
1096       Making an Rlogin connection
1097              This is just like Telnet, except you have to be root to do it
1098              because Rlogin uses a privileged TCP port:
1099
1100                rlogin foo.bar.com
1101
1102              More info: HELP RLOGIN.
1103
1104       Making an SSH Connection
1105              Unlike Telnet and Rlogin, SSH connections are not built‐in, but
1106              handled by running your external SSH client through a pseudoter‐
1107              minal.  Using C‐Kermit to control the SSH client gives you all
1108              of Kermit's features (file transfer, character‐set conversion,
1109              scripting, etc) over SSH.
1110
1111                ssh foo.bar.com
1112
1113              More info: HELP SSH, HELP SET SSH.
1114
1115       Dialing with a Modem
1116              If it's an external modem, make sure it is connected to a usable
1117              serial port on your computer with a regular (straight‐through)
1118              modem cable, and to the telephone jack with a telephone cable,
1119              and that it's turned on. Then use these commands:
1120
1121                set modem type usrobotics  ; Or other supported type
1122                set line /dev/ttyS0        ; Specify device name
1123                set speed 57600            ; Or other desired speed
1124                set flow rts/cts           ; Most modern modems support this
1125                set dial method tone       ; (or pulse)
1126                dial 7654321               ; Dial the desired number
1127
1128              Type "set modem type ?" for a list of supported modem types. If
1129              you omit the SET MODEM TYPE command, the default type is
1130              "generic‐high‐speed", which should work for most modern AT‐com‐
1131              mand‐set modems. If the line is busy, Kermit redials automati‐
1132              cally. If the call does not succeed, use "set dial display on"
1133              and try it again to watch what happens. If the call succeeds,
1134              Kermit enters Connect state automatically and returns to its
1135              prompt automatically when you log out from the remote computer
1136              or the connection is otherwise lost.
1137
1138              You can also dial from a modem that is accessible by Telnet,
1139              e.g. to a reverse terminal server. In this case the command
1140              sequence is:
1141
1142                set host ts.xxx.com 2000   ; Terminal‐server and port
1143                set modem type usrobotics  ; Or other supported type
1144                set dial method tone       ; (or pulse)
1145                dial 7654321               ; Dial the desired number
1146
1147              If the terminal server supports the Telnet Com Port Option, RFC
1148              2217, you can also give serial‐port related commands such as SET
1149              SPEED, SET PARITY, and so on, and Kermit relays them to the ter‐
1150              minal server using the protocol specified in the RFC.
1151
1152              More info: HELP SET MODEM, HELP SET LINE, HELP SET SPEED, HELP
1153              SET FLOW, HELP DIAL, HELP SET DIAL, HELP SET MODEM, HELP SET
1154              CARRIER-WATCH, SHOW COMMUNICATIONS, SHOW MODEM, SHOW DIAL.
1155
1156       Direct Serial Port
1157              Connect the two computers, A and B, with a null modem cable (or
1158              two modem cables interconnected with a null‐modem adapter or
1159              modem eliminator). From Computer A:
1160
1161                set modem type none   ; There is no modem
1162                set line /dev/ttyS0   ; Specify device name
1163                set carrier-watch off ; If DTR CD are not cross‐connected
1164                set speed 57600       ; Or other desired speed
1165                set flow rts/cts      ; If RTS and CTS are cross‐connected
1166                set parity even       ; (or "mark" or "space", if necessary)
1167                set stop-bits 2       ; (rarely necessary)
1168                set flow xon/xoff     ; If you can't use RTS/CTS
1169                connect               ; Enter Connect (terminal) state
1170
1171              This assumes Computer B is set up to let you log in. If it
1172              isn't, you can run a copy of Kermit on Computer B and follow
1173              approximately the same directions. More info: As above plus HELP
1174              CONNECT.
1175
1176       With modems or direct serial connections, you might also have to "set
1177       parity even" (or "mark" or "space") if it's a 7‐bit connection.
1178
1179       Of the connection types listed above, only one can be open at a time.
1180       However, any one of these can be open concurrently with an FTP or HTTP
1181       session. Each connection type can be customized to any desired degree,
1182       scripted, logged, you name it. See the manual.
1183
1184       NOTE: On selected platforms, C‐Kermit also can make X.25 connections.
1185       See the manual for details.
1186

TRANSFERRING FILES WITH KERMIT

1188       There is a widespread and persistent belief that Kermit is a slow pro‐
1189       tocol.  This is because, until recently, it used conservative tuning by
1190       default to make sure file transfers succeeded, rather than failing
1191       because they overloaded the connection. Some extra commands (or com‐
1192       mand‐line options, like -Q) were needed to make it go fast, but nobody
1193       bothered to find out about them. Also, it takes two to tango: most non‐
1194       Kermit‐Project Kermit protocol implementations really ARE slow. The
1195       best file‐transfer partners for C‐Kermit are: another copy of C‐Kermit
1196       (7.0 or later) and Kermit 95.  These combinations work well and they
1197       work fast by default. MS‐DOS Kermit is good too, but you have to tell
1198       it to go fast (by giving it the FAST command).
1199
1200       Furthermore, all three of these Kermit programs support "autodownload"
1201       and "autoupload", meaning that when they are in Connect state and a
1202       Kermit packet comes in from the remote, they automatically switch into
1203       file transfer mode.
1204
1205       And plus, C‐Kermit and K95 also switch automatically between text and
1206       binary mode for each file, so there is no need to "set file type
1207       binary" or "set file type text", or to worry about files being cor‐
1208       rupted because they were transferred in the wrong mode.
1209
1210       What all of these words add up to is that now, when you use up‐to‐date
1211       Kermit software from the Kermit Project, file transfer is not only
1212       fast, it's ridiculously easy. You barely have to give any commands at
1213       all.
1214
1215       Downloading Files
1216              Let's say you have Kermit 95, C‐Kermit, or MS‐DOS Kermit on your
1217              desktop computer, with a connection to a Unix computer that has
1218              C‐Kermit installed as "kermit". To download a file (send it from
1219              Unix to your desktop computer), just type the following command
1220              at your Unix shell prompt:
1221
1222                kermit -s oofa.txt
1223
1224              (where oofa.txt is the filename). If you want to send more than
1225              one file, you can put as many filenames as you want on the com‐
1226              mand line, and they can be any combination of text and binary:
1227
1228                kermit -s oofa.txt oofa.zip oofa.html oofa.tar.gz
1229
1230              and/or you can use wildcards to send groups of files:
1231
1232                kermit -s oofa.*
1233
1234              If you want to send a file under an assumed name, use:
1235
1236                kermit -s friday.txt -a today.txt
1237
1238              This sends the file friday.txt but tells the receiving Kermit
1239              that its name is today.txt. In all cases, as noted, when the
1240              file transfer is finished, your desktop Kermit returns automati‐
1241              cally to Connect state.  No worries about escaping back, re‐con‐
1242              necting, text/binary mode switching. Almost too easy, right?
1243
1244       Uploading Files
1245              To upload files (send them from your desktop computer to the
1246              remote Unix computer) do the same thing, but use the -g (GET)
1247              option instead of -s:
1248
1249                kermit -g oofa.txt
1250
1251              This causes your local Kermit to enter server mode; then the
1252              remote Kermit program requests the named file and the local Ker‐
1253              mit sends it and returns automatically to Connect state when
1254              done.
1255
1256              If you want to upload multiple files, you have have use shell
1257              quoting rules, since these aren't local files:
1258
1259                kermit -g "oofa.txt oofa.zip oofa.html oofa.tar.gz"
1260                kermit -g "oofa.*"
1261
1262              If you want to upload a file but store it under a different
1263              name, use:
1264
1265                kermit -g friday.txt -a today.txt
1266
1267       Kermit Transfers the Old‐Fashioned Way
1268              If your desktop communications software does not support autou‐
1269              pload or autodownload, or it does not include Kermit server
1270              mode, the procedure requires more steps.
1271
1272              To download a file, type:
1273
1274                kermit -s filename
1275
1276              on the host as before, but if nothing happens automatically in
1277              response to this command, you have to switch your desktop commu‐
1278              nications software into Kermit Receive state. This might be done
1279              by escaping back using keyboard characters or hot keys (Alt-x is
1280              typical) and/or with a command (like RECEIVE) or a menu. When
1281              the file transfer is complete, you have to go back to Connect
1282              state, Terminal emulation, or whatever terminology applies to
1283              your desktop communications software.
1284
1285              To upload a file, type:
1286
1287                kermit -r
1288
1289              on the host (rather than "kermit -g"). This tells C‐Kermit to
1290              wait passively for a file to start arriving. Then regain the
1291              attention of your desktop software (Alt-x or whatever) and
1292              instruct it to send the desired file(s) with Kermit protocol.
1293              When the transfer is finished, return to the Connect or Terminal
1294              screen.
1295
1296       If File Transfer Fails
1297              Although every aspect of Kermit's operation can be finely tuned,
1298              there are also three short and simple "omnibus tuning" commands
1299              you can use for troubleshooting:
1300
1301              FAST   Use fast file‐transfer settings. This has been the
1302                     default since C‐Kermit 7.0 now that most modern computers
1303                     and connections support it. If transfers fail with fast
1304                     settings, try . . .
1305
1306              CAUTIOUS
1307                     Use cautious but not paranoid settings. File transfers,
1308                     if they work, will go at medium speed. If not, try . . .
1309
1310              ROBUST Use the most robust, resilient, conservative, safe, and
1311                     reliable settings. File transfers will almost certainly
1312                     work, but they will be quite slow (of course this is a
1313                     classic tradeoff; ROBUST was C‐Kermit's default tuning in
1314                     versions 6.0 and earlier, which made everybody think Ker‐
1315                     mit protocol was slow). If ROBUST doesn't do the trick,
1316                     try again with SET PARITY SPACE first in case it's not an
1317                     8‐bit connection.
1318
1319       Obviously the success and performance of a file transfer also depends
1320       on C‐Kermit's file transfer partner. Up‐to‐date, real Kermit Project
1321       partners are recommended because they contain the best Kermit protocol
1322       implementations and because we can support them in case of trouble.
1323
1324       If you still have trouble, consult Chapter 10 of Using C‐Kermit, or
1325       send email to kermit‐support@columbia.edu.
1326
1327       Advanced Kermit File‐Transfer Features
1328              Obviously there is a lot more to Kermit file transfer, including
1329              all sorts of interactive commands, preferences, options, log‐
1330              ging, debugging, troubleshooting, and anything else you can
1331              imagine but that's what the manual and updates are for. Here are
1332              a few topics you can explore if you're interested by Typing HELP
1333              for the listed commands:
1334
1335              Logging transfers:
1336                     LOG TRANSACTIONS (HELP LOG)
1337
1338              Automatic per‐file text/binary mode switching:
1339                     SET TRANSFER MODE { AUTOMATIC, MANUAL } (HELP SET TRANS‐
1340                     FER).
1341
1342              Cross‐platform recursive directory tree transfer:
1343                     SEND /RECURSIVE, GET /RECURSIVE (HELP SEND, HELP GET).
1344
1345              File collision options:
1346                     SET FILE COLLISION { OVERWRITE, BACKUP, DISCARD, ... }
1347                     (HELP SET FILE).
1348
1349              Update: Transfer only files that changed since last time:
1350                     SET FILE COLLISION UPDATE (HELP SET FILE).
1351
1352              Filename selection patterns:
1353                     (HELP WILDCARD).
1354
1355              Flexible file selection:
1356                     SEND (or GET) /BEFORE /AFTER /LARGER /SMALLER /TYPE
1357                     /EXCEPT, ...
1358
1359              Character‐set conversion:
1360                     SET { FILE, TRANSFER } CHARACTER-SET, ASSOCIATE, ...
1361
1362              File/Pathname control:
1363                     SET { SEND, RECEIVE } PATHNAMES, SET FILE NAMES.
1364
1365              Atomic file movement:
1366                     SEND (or GET) /DELETE /RENAME /MOVE-TO
1367
1368              Transferring to/from standard i/o of other commands:
1369                     SEND (or GET) /COMMAND
1370
1371              Recovery of interrupted transfer from point of failure:
1372                     RESEND, REGET (HELP RESEND, HELP REGET).
1373
1374       Non‐Kermit File Transfer
1375              You can also use C‐Kermit to transfer files with FTP or HTTP
1376              Internet protocols; see below.
1377
1378              On a regular serial or Telnet connection where the other com‐
1379              puter doesn't support Kermit protocol at all, you have several
1380              options. For example, if your desktop communications software
1381              supports Zmodem, use "rz" and "sz" on the host rather than Ker‐
1382              mit. But if Kermit is your desktop software, and you are using
1383              it to make calls or network connections to other computers that
1384              don't support Kermit protocol (or that don't have a good imple‐
1385              mentation of it), then if your computer also has external X, Y,
1386              or Zmodem programs that are redirectable, Kermit can use them as
1387              external protocols. HELP SET PROTOCOL for details.
1388
1389              You can also capture "raw" data streams from the other computer
1390              with LOG SESSION (HELP LOG and HELP SET SESSION-LOG for
1391              details), and you can upload files without any protocol at all
1392              with TRANSMIT (HELP TRANSMIT, HELP SET TRANSMIT).
1393

KERMIT'S BUILT‐IN FTP AND HTTP CLIENTS

1395       Kermit's FTP client is like the regular Unix FTP client that you're
1396       used to, but with some differences:
1397
1398       ·      It has lots more commands and features.
1399
1400       ·      Each FTP command must be prefixed with "ftp", for example "ftp
1401              open", "ftp get", "ftp bye", etc (this is not strictly true, but
1402              until you're more familiar with it, it's best to follow this
1403              rule).
1404
1405       ·      Commands like "cd", "directory", etc, execute locally, not on
1406              the server. Use "ftp cd", "ftp dir", etc, to have them act on
1407              the server.
1408
1409       ·      You can have an FTP session and a regular Kermit serial or Tel‐
1410              net session open at the same time.
1411
1412       ·      FTP sessions can be fully automated.
1413
1414       Pending publication of the next edition of the manual, the Kermit FTP
1415       client is thoroughly documented at the Kermit Project website:
1416
1417         http://www.columbia.edu/kermit/ftpclient.html
1418
1419       You also can use HELP FTP and HELP SET FTP to get descriptions of Ker‐
1420       mit's FTP‐related commands.
1421
1422       The HTTP client is similar to the FTP one, except you prefix each com‐
1423       mand with HTTP instead of FTP: HTTP OPEN, HTTP GET, HTTP PUT, HTTP
1424       CLOSE, etc.  Type HELP HTTP for details, or visit the to view the man‐
1425       ual supplements.  HTTP connections can be open at the same time as reg‐
1426       ular serial or Telnet connections and FTP connections. So Kermit can
1427       manage up to three types connections simultaneously.
1428

INTERNET KERMIT SERVICE

1430       C‐Kermit can be configured and run as an Internet service (called
1431       IKSD), similar to an FTP server (FTPD) except you can (but need not)
1432       interact with it directly, plus it does a lot more than an FTP server
1433       can do. The TCP port for IKSD is 1649. It uses Telnet protocol. C‐Ker‐
1434       mit can be an Internet Kermit Server, or it can be a client of an IKSD.
1435       You can make connections from C‐Kermit to an IKSD with any of the fol‐
1436       lowing commands:
1437
1438         telnet foo.bar.edu 1649
1439         telnet foo.bar.edu kermit   ; if "kermit" is listed in /etc/services
1440         iksd foo.bar.edu
1441
1442       The IKSD command is equivalent to a TELNET command specifying port
1443       1649.  For more information about making and using connections to an
1444       IKSD, see:
1445
1446         http://www.columbia.edu/kermit/cuiksd.html
1447
1448       You can run an Internet Kermit Service on your own computer too (if you
1449       are the system administrator). For instructions, see:
1450
1451         http://www.columbia.edu/kermit/iksd.html
1452

SECURITY

1454       All of C‐Kermit's built‐in TCP/IP networking methods (Telnet, Rlogin,
1455       IKSD, FTP, and HTTP) can be secured by one or more of the following
1456       IETF‐approved methods:
1457
1458       ·    MIT Kerberos IV
1459       ·    MIT Kerberos V
1460       ·    SSL/TLS
1461       ·    Stanford SRP
1462
1463       For complete instructions see:
1464
1465         http://www.columbia.edu/kermit/security.html
1466
1467       And as noted previously, you can also make SSH connections with C‐Ker‐
1468       mit if you already have an SSH client installed.
1469

ALTERNATIVE COMMAND‐LINE PERSONALITIES

1471       When invoked as "kermit" or any other name besides "ftp" or "telnet",
1472       C‐Kermit has the command‐line options described above in the OPTIONS
1473       section. However, if you invoke C‐Kermit as "telnet" or "ftp", it
1474       changes its command‐line personality to match. This can be done (among
1475       other ways) with symbolic links (symlinks). For example, if you want C‐
1476       Kermit to be your regular Telnet client, or the Telnet helper of your
1477       Web browser, you can create a link like the following in a directory
1478       that lies in your PATH ahead of the regular telnet program:
1479
1480         ln -s /usr/local/bin/kermit telnet
1481
1482       Now when you give a "telnet" command, you are invoking Kermit instead,
1483       but with its Telnet command‐line personality so, for example:
1484
1485         telnet xyzcorp.com
1486
1487       Makes a Telnet connection to xyzcorp.com, and Kermit exits automati‐
1488       cally when the connection is closed (just like the regular Telnet
1489       client). Type "telnet -h" to get a list of Kermit's Telnet‐personality
1490       command‐line options, which are intended to be as compatible as possi‐
1491       ble with the regular Telnet client.
1492
1493       Similarly for FTP:
1494
1495         ln -s /usr/local/bin/kermit ftp
1496
1497       And now type "ftp -h" to see its command‐line options, and command
1498       lines just like you would give your regular FTP client:
1499
1500         ftp xyzcorp.com
1501
1502       but with additional options allowing an entire session to be specified
1503       on the command line. Finally, if Kermit's first command‐line option is
1504       a Telnet, FTP, IKSD, or HTTP URL, Kermit automatically makes the appro‐
1505       priate kind of connection and, if indicated by the URL, takes the
1506       desired action:
1507
1508       kermit telnet:xyzcorp.com
1509              Opens a Telnet session
1510
1511       kermit telnet://olga@xyzcorp.com
1512              Ditto for user olga
1513
1514       kermit ftp://olga@xyzcorp.com/public/oofa.zip
1515              Downloads a file
1516
1517       kermit kermit://kermit.columbia.edu/kermit/f/READ.ME
1518              Ditto for IKSD
1519
1520       kermit iksd://kermit.columbia.edu/kermit/f/READ.ME
1521              (This works too)
1522
1523       kermit http://www.columbia.edu/kermit/index.html
1524              Grabs a web page
1525

LICENSE

1527       C‐Kermit has an unusual license, but a fair and sensible one since the
1528       Kermit Project must support itself out of revenue: it's not a BSD
1529       license, not GPL, not Artistic, not commercial, not shareware, not
1530       freeware. It can be summed up like this: if you want C‐Kermit for your
1531       own use, you can download and use it without cost or license (but we'd
1532       appreciate it if you would purchase the manual). But if you want to
1533       sell C‐Kermit or bundle it with a product or otherwise distribute it in
1534       a commercial setting EXCEPT WITH AN OPEN‐SOURCE OPERATING SYSTEM DIS‐
1535       TRIBUTION such as Linux, FreeBSD, NetBSD, or OpenBSD, you must license
1536       it. To see the complete license, give the LICENSE command at the
1537       prompt, or see the COPYING.TXT file distributed with C‐Kermit 7.0 or
1538       later, or download it from
1539
1540         ftp://kermit.columbia.edu/kermit/c-kermit/COPYING.TXT
1541
1542       Send licensing inquiries to kermit@columbia.edu.
1543

BUGS

1545       See the following files for listings of known bugs, limitations, work‐
1546       arounds, hints and tips:
1547
1548       ckcbwr.txt
1549              General C‐Kermit bugs, hints, tips.
1550
1551       ckubwr.txt
1552              Unix‐specific C‐Kermit bugs, hints, tips.
1553
1554       Report bugs and problems by email to:
1555
1556          kermit-support@columbia.edu.
1557
1558       Before requesting technical support, please read the hints here:
1559
1560         http://www.columbia.edu/kermit/support.html
1561
1562       and also read the C‐Kermit Frequently Asked Questions:
1563
1564         http://www.columbia.edu/kermit/ckfaq.html
1565

OTHER TOPICS

1567       There's way more to C‐Kermit than we've touched on here ‐‐ trou‐
1568       bleshooting, customization, character sets, dialing directories, send‐
1569       ing pages, script writing, and on and on, all of which are covered in
1570       the manual and updates and supplements. For the most up‐to‐date infor‐
1571       mation on documentation (or updated documentation itself) visit the
1572       Kermit Project website:
1573
1574         http://www.columbia.edu/kermit/
1575
1576       There you will also find Kermit software packages for other platforms:
1577       different Unix varieties, Windows, DOS, VMS, IBM mainframes, and many
1578       others: 20+ years' worth.
1579

DOCUMENTATION AND UPDATES

1581       The manual for C‐Kermit is:
1582
1583       Using C‐Kermit
1584              Frank da Cruz and Christine M. Gianone, Second Edition, Digital
1585              Press / Butterworth‐Heinemann, Woburn, MA, 1997, 622 pages, ISBN
1586              1-55558-164-1. This is a printed book. It covers C‐Kermit 6.0.
1587
1588       The C‐Kermit 7.0 Supplement
1589              http://www.columbia.edu/kermit/ckermit70.html
1590
1591       The C‐Kermit 8.0 Supplement
1592              http://www.columbia.edu/kermit/ckermit80.html
1593
1594       The C‐Kermit 9.0 Supplement
1595              http://www.columbia.edu/kermit/ckermit90.html
1596
1597       Visit C‐Kermit home page:
1598
1599         http://www.columbia.edu/kermit/ckermit.html
1600
1601       to learn about new versions, Beta tests, and other news; to read case
1602       studies and tutorials; to download source code, install packages, and
1603       prebuilt binaries for many platforms. Also visit:
1604
1605       http://www.columbia.edu/kermit/scriptlib.html
1606              The Kermit script library and tutorial
1607
1608       http://www.columbia.edu/kermit/newfaq.html
1609              The Kermit FAQ (Frequently Asked Questions about Kermit)
1610
1611       http://www.columbia.edu/kermit/ckfaq.html
1612              The C‐Kermit FAQ (Frequently Asked Questions about C‐Kermit)
1613
1614       http://www.columbia.edu/kermit/telnet.html
1615              C‐Kermit Telnet client documentation
1616
1617       http://www.columbia.edu/kermit/security.html
1618              C‐Kermit security documentation (Kerberos, SSL/TLS, etc)
1619
1620       http://www.columbia.edu/kermit/cuiksd.html
1621              Internet Kermit Service user documentation
1622
1623       http://www.columbia.edu/kermit/iksd.html
1624              Internet Kermit Service administrator documentation
1625
1626       http://www.columbia.edu/kermit/studies.html
1627              Case studies.
1628
1629       http://www.columbia.edu/kermit/support.html
1630              Technical support.
1631
1632       http://www.columbia.edu/kermit/k95tutorial.html
1633              Kermit 95 tutorial.
1634
1635       comp.protocols.kermit.misc
1636              The Kermit newsgroup (unmoderated).
1637

FILES

1639       COPYING.TXT
1640              C‐Kermit license.
1641
1642       ~/.kermrc
1643              Initialization file.
1644
1645       ~/.mykermrc
1646              Customization file.
1647
1648       ~/.kdd Kermit dialing directory (see manual).
1649
1650       ~/.knd Kermit network directory (see manual).
1651
1652       ~/.ksd Kermit services directory (see manual).
1653
1654       ca_certs.pem
1655              Certificate Authority certifcates used for SSL connections.
1656
1657       ckuins.txt
1658              Installation instructions for Unix.  Also at http://www.colum
1659              bia.edu/kermit/ckuins.html.
1660
1661       ckcbwr.txt
1662              General C‐Kermit bugs, hints, tips.
1663
1664       ckubwr.txt
1665              Unix‐specific C‐Kermit bugs, hints, tips.
1666
1667       ckcplm.txt
1668              C‐Kermit program logic manual.
1669
1670       ckccfg.txt
1671              C‐Kermit compile‐time configuration options.
1672
1673       ssh    (in your PATH) SSH connection helper.
1674
1675       rz, sz, etc.
1676              (in your PATH) external protocols for XYZmodem.
1677
1678       /var/spool/locks (or whatever)
1679              UUCP lockfile for dialing out (see installation instructions).
1680

AUTHORS

1682       Software
1683              Frank da Cruz and Jeffrey E Altman,
1684              1985‐present, with contributions from hundreds of others all
1685              over the world.
1686
1687       Documentation
1688              Frank da Cruz
1689
1690       Address
1691              The Kermit Project ‐ Columbia Univerity
1692              612 West 115th Street
1693              New York NY 10025-7799
1694              USA
1695
1696       E‐Mail kermit@columbia.edu
1697
1698       Web    http://www.columbia.edu/kermit/
1699
1700
1701
1702User Manuals                       JULY 2011                         KERMIT(1)
Impressum