home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / archives / ckc190.tar.gz / ckc190.tar / ckmker.mss < prev    next >
Text File  |  1994-08-16  |  48KB  |  958 lines

  1. @Part(CKMKER,root="kuser")
  2. @string(-ckmver="@q<0.9(40)>")
  3.  
  4. @Chapter<MACINTOSH KERMIT>
  5.  
  6. @case(device,file="@*--------@*
  7. This document is formatted as an ordinary, plain text ASCII disk file, from
  8. SCRIBE text formatter source.  Typeset copies are available from Columbia
  9. University.@*--------@*")
  10.  
  11. @Begin<Description,spread 0>
  12. @i(Program:)@\Bill Catchings, Bill Schilit, Frank da Cruz (Columbia
  13. University),@*
  14. Davide Cervone (University of Rochester),@*
  15. Matthias Aebi (ECOFIN Research and Consulting, Ltd., Zuerich),@*
  16. Paul Placeway (Ohio State University).
  17.  
  18. @i(Language:)@\C (MPW)
  19.  
  20. @i(Documentation:)@\Christine Gianone, Frank da Cruz, Paul Placeway
  21.  
  22. @i(Version:)@\@value(-ckmver)
  23.  
  24. @i(Date: )@\May 26, 1988
  25. @end<Description>
  26.  
  27. @subheading<MacKermit Capabilities At A Glance:>
  28. @begin<format,leftmargin +2,above 1,below 1>
  29. @tabclear()@tabset(3.5inches,4.0inches)
  30. Local operation:@\Yes
  31. Remote operation:@\Yes (server mode only)
  32. Login scripts:@\No
  33. Transfer text files:@\Yes
  34. Transfer binary files:@\Yes
  35. MacBinary transfers:@\No
  36. Wildcard send:@\Yes (whole HFS folders)
  37. File transfer interruption:@\Yes
  38. Filename collision avoidance:@\Yes
  39. Can time out:@\Yes
  40. 8th-bit prefixing:@\Yes
  41. Repeat count prefixing:@\Yes
  42. Alternate block checks:@\Yes
  43. Terminal emulation:@\Yes (VT100,VT102)
  44. Communication settings:@\Yes (Speed, Parity, Echo)
  45. XON/XOFF:@\Yes
  46. Transmit BREAK:@\Yes
  47. IBM mainframe communication:@\Yes
  48. Transaction logging:@\Yes
  49. Session logging:@\Yes
  50. Debug logging:@\No
  51. Packet logging:@\No
  52. Act as server:@\Yes
  53. Talk to server:@\Yes
  54. Advanced server functions:@\Yes
  55. Local file management:@\Yes
  56. Command/Init files:@\No
  57. Key redefinition/macros:@\Yes
  58. File attributes packets:@\No
  59. Command macros:@\No
  60. Raw file transmit:@\No
  61. Long packets:@\Yes
  62. Sliding windows:@\No
  63. @end<format>
  64.  
  65. @section(Introduction)
  66. @index<Apple Macintosh>
  67. @index<Macintosh Kermit>
  68. @index<CKMKER>
  69.  Macintosh Kermit, or "MacKermit", is an implementation of the Kermit file
  70. transfer protocol for the Apple Macintosh family of computers. It was
  71. developed at Columbia University, based on C-Kermit (which also forms the
  72. nucleus of Unix Kermit and many other Kermit programs).  Version 0.9 of
  73. MacKermit runs on the Macintosh 512, XL (Apple Lisa running MacWorks), 512e,
  74. Plus, SE, and II, under the regular Finder and the Multifinder, with which it
  75. can transfer files in the background@index<Background>.  MacKermit 0.9
  76. probably does not run on a 128k (original, classic) Macintosh, due to lack of
  77. sufficient memory, but should run OK on a "fat Mac" (a 128K Mac upgraded to
  78. 512K).  Version 0.8 should be retained for 128K Macs.
  79.  
  80. This manual assumes you are acquainted with your Macintosh, and that you are
  81. familiar with the general ideas of data communication and Kermit file transfer.
  82. A very brief overview is given here, but for details consult the early chapters
  83. of the @i<Kermit User Guide> (of which this document is a chapter), or the book
  84. @ux<Kermit, A File Transfer Protocol>, by Frank @w<da Cruz>, Digital Press
  85. (1987).  For further information about Kermit documentation, updates, lists of
  86. current available versions, and ordering information, write to:
  87. @begin<example,use r,need 5>
  88. Kermit Distribution
  89. Columbia University Center for Computing Activities
  90. 612 West 115th Street
  91. New York, NY  10025  (USA)
  92. @end<example>
  93.  
  94. @Section<Installation>
  95.  
  96. Before you can use Macintosh Kermit or any other communication program on your
  97. Mac, you must have a way to connect it to the other computers you wish to
  98. communicate with.  This means either a direct cable connection (usually using
  99. a "null modem" cable), or a modem connected to your Mac and to a telephone.
  100. The Macintosh poses two special problems at this level.  First, its connectors
  101. are not the standard 25-pin RS-232 style, but either 9-pin or 8-pin special
  102. connectors which you need special adapters for.  Second, the Macintosh does
  103. not supply a Data Terminal Ready (DTR@index<DTR>) signal, which is required by
  104. most modems before they will operate.  To use your Mac with a modem that is
  105. not designed specifically for the Mac, you have to either (a) configure the
  106. modem to ignore the DTR signal, or (b) feed some other active signal into the
  107. modem's DTR input.  The former is usually done with DIP switches on the modem,
  108. the latter can be done in the connector that plugs into the modem by
  109. installing a jumper wire between DTR (pin 20) and DSR (pin 6), or by
  110. connecting the Mac's +12V output (pin 6 on the Mac's 9-pin connector) to DTR
  111. (pin 20) on the modem end.
  112.  
  113. If you have received a Macintosh Kermit diskette from Columbia University,
  114. there's no special software installation procedure -- just insert the
  115. diskette, double-click on the appropriate start-up file, or on MacKermit
  116. itself, and go.  If all the communication and other settings agree with your
  117. requirements, there's nothing else you need to do.  This process is
  118. illustrated in the next section, just below.
  119.  
  120. MacKermit is not copy-protected, and nothing out of the ordinary is required
  121. to make copies onto other diskettes, or onto your hard disk if you have one.
  122. Just use the ordinary Macintosh methods of copying files, folders, etc.
  123.  
  124. Later, you may wish to create settings files tailored to your communication
  125. environment, and you might also want to customize the keyboard configuration.
  126. Use the various Settings options for this, and then select Save Settings from
  127. the File menu.  Settings and settings files are explained in Sections
  128. @ref<-macset> and @ref<-macsfile>.
  129.  
  130. @section(Getting Started)
  131. @label<-macstart>
  132.  
  133. Kermit programs perform two major functions, terminal emulation and file
  134. transfer.  Before transferring files between two systems you must establish a
  135. terminal connection from your system to the other one, either direct or else
  136. dialed up using a modem.  Then to transfer files, login to the remote system
  137. if necessary, start up a Kermit program there, and then tell the two Kermit
  138. programs which files to transfer, and in what direction.
  139.  
  140. Most Kermit programs present you with a prompt, in response to which you type
  141. a command, repeating the process until you exit from the program.  If you want
  142. to establish a terminal connection to another system, you must give the
  143. CONNECT command.  Unlike these programs, MacKermit is @i<always> connected,
  144. and whatever keystrokes you type are sent to the other system.  To give
  145. commands to MacKermit itself, you must use the mouse@index(Mouse) to pull down
  146. menus from the menu bar that overlays your terminal session, or type special
  147. Command-key equivalents.
  148.  
  149. The following example shows how to transfer a file with MacKermit.  The remote
  150. computer is a Unix system, but the method is the same with most others.
  151. @begin(itemize)
  152. First insert the MacKermit diskette.  It should appear on the screen as a
  153. diskette icon titled @b<Kermit 0.9(40)>.  Click on it twice to open if it did
  154. not open automatically when you inserted it in the drive.
  155.  
  156. Once the disk is opened, you will see three MacKermit icons across the top of
  157. the screen.  For the Unix system and most others you can use the "@b(Normal
  158. Settings)" icon -- to start the Kermit program click twice on it.  For linemode
  159. connections to IBM mainframes, you would click twice on the "@b(IBM Mainframe
  160. Linemode Settings)" icon.
  161.  
  162. You will see a white backround with menus stored under the headings @b(File),
  163. @b(Edit), @b(Settings), @b(Remote), and @b(Log).
  164.  
  165. Move the mouse pointer to the @b(Settings) menu and select
  166. @b(Communications...) by clicking on it once.
  167.  
  168. MacKermit normally sets the communication speed to 9600 bits per second.
  169. Click on the circle in front of 1200 (or whatever speed you need to match the
  170. baud rate of your modem and/or remote system).  Check to see that the other
  171. communication settings like parity are as required, and make any necessary
  172. changes.
  173.  
  174. Click on the "@q<OK>" box to accept the settings.
  175.  
  176. If you have a Hayes-like dialout modem, follow the next two steps:
  177. @begin<enumerate>
  178. Type AT (uppercase) and then press the Enter key.  The modem should respond
  179. with "OK" or the digit "0" (zero).  If it doesn't, check the cable, the modem,
  180. etc (consult your modem manual for details).
  181.  
  182. Now type ATDT 7654321 followed by Enter (replace 7654321 by the actual phone
  183. number).  If the connection succeeds, you'll get a message like CONNECT (or the
  184. digit "1"), otherwise you'll see an error message like NO CARRIER, ERROR, etc,
  185. or a digit like 3 or 4 (see your modem manual).
  186. @end<enumerate>
  187. For non-Hayes-compatible modems, follow the instructions in your modem manual.
  188. For direct connections, skip this step altogether.
  189. @end<itemize>
  190. Now you should be talking to the Unix system.  Type a carriage return to get
  191. its attention, and it will issue its login prompt.  In the examples below,
  192. underlining is used to show the parts that you would type.
  193. @begin<example>
  194. @tabclear()@tabset(2.5inches)
  195. Login: @ux<christin>@\@i(Login to the host.)
  196. password:@ux<      >@\@i<(Passwords normally don't echo.)>
  197.  
  198. % @ux<kermit>@\@i(Run Kermit on the host.)
  199.  
  200. C-Kermit>@ux<receive>@\@i(Tell it to receive a file.)
  201. @end<example>
  202.  
  203. Now tell MacKermit what file to send:
  204. @begin<itemize>
  205. Use the mouse to point to the @b(File) menu and select the @b(Send File...)
  206. option.  You can either type in the name of the file (if you know the name) or
  207. select the alternate drive to see what files are on the disk.  Once you see
  208. the file you want to send, click on the filename and then click on the SEND
  209. option (or you can just click twice on the filename).
  210.  
  211. A "File Transfer Status" box will appear to report the progress of the
  212. transer.  @i(NOTE:) If the number of retries is increasing but not the number
  213. of packets, you should check your @b(Communications...) settings under the
  214. @b(Settings) menu.
  215.  
  216. When the file transfer is completed, the "File Transfer Status" box should
  217. disappear and the C-Kermit prompt should reappear.  
  218. @end(itemize)
  219.  
  220. You have just transferred a file from the Macintosh to the Unix system.  To
  221. transfer a file in the other direction, use the "@q(send )@i<filename>"
  222. command on Unix instead of "@q(receive)", and click on "@b(Receive File...)"
  223. from the Mac's @b(File) menu, instead of "@b(Send File...)".
  224.  
  225. After the file is transferred, your terminal connection is automatically
  226. resumed.  Once your Unix session is complete, you can log out, and then
  227. exit from MacKermit:
  228. @begin<example>
  229. @tabclear()@tabset(2.5inches)
  230. C-Kermit>@ux<exit>
  231.  
  232. % @ux<^D>@\@i(Logout from Unix by typing Ctrl-D.)
  233. @end<example>
  234.  
  235. @begin<enumerate,spread 0.5>
  236. Select the @b(Quit) option in the @b(File) menu by clicking on it.
  237.  
  238. Select the @b(Close) option in the @b(File) menu by clicking on it (assuming
  239. you want to close the current folder).
  240.  
  241. Select the @b(Eject) option in the @b(File) menu by clicking on it (assuming
  242. you ran Kermit from a diskette that you want to eject).
  243. @end<enumerate>
  244. That's the easiest and quickest way to use Kermit.  If this simple scenario
  245. does not work for you, look for any obvious incorrect settings (speed, parity),
  246. fix them, and try again.  Otherwise, read on.
  247.  
  248. @Section(The Macintosh File System)
  249.  
  250. The Macintosh file system consists of one or more disks, each disk containing
  251. files.  There are actually two Macintosh file systems, which work slightly
  252. differently.
  253.  
  254. Disks formatted for the older Macintosh File System (MFS)@index<MFS> are
  255. essentially "flat".  All files on one of these disks must have a unique name.
  256. Files may be collected together into "folders"@index<Folder>, but folders are
  257. not analogous to directories on other file systems, and no two folders on the
  258. same disk may contain files of the same name; the folders exist only to make
  259. things look nicer in the Finder.  All Macintoshes have support for MFS.
  260.  
  261. Disks formatted with the newer Hierarchical File System (HFS)@index<HFS> are
  262. not "flat"; each folder is a directory.  There may not be more than one file
  263. with the same name in a single folder, but there may be identically named
  264. files in different folders.
  265.  
  266. Macintosh file names may contain practically any printable characters,
  267. including space and punctuation -- but colon (@qq[:]) may not be used; it is
  268. used in device names and as the HFS path element separator.
  269.  
  270. @section(Menus)
  271.  
  272. The major menus are @b(Apple), @b(File), @b(Edit), @b(Settings), @b(Remote),
  273. and @b(Log).  The @b(Apple) menu gives some information about the program,
  274. including the MacKermit version number and the C-Kermit protocol mudule version
  275. number (useful in reporting bugs).  It also shows statistics about the most
  276. recent file transfer.
  277.  
  278. The @b(File) menu invokes Kermit's file transfer functions, @b(Send), @b(Get),
  279. and @b(Receive).  It also allows settings to
  280. be saved and restored, and like most Macintosh applications, includes a "quit"
  281. entry for leaving the program, and a "transfer" entry for transferring to
  282. another program without going through the Finder.
  283.  
  284. The @b(Edit) menu provides support for Macintosh desk accessories that need to
  285. have this menu to do cut and paste.  This menu does not currently do anything
  286. in MacKermit.
  287.  
  288. The @b(Settings) menu provides dialog boxes for file, communications, and
  289. protocol settings; these will be discussed below.
  290.  
  291. The @b(Remote) menu has the commands that can be sent to Kermit servers, as
  292. well as an option to turn Macintosh Kermit itself into a server (also
  293. discussed below).
  294.  
  295. The @b(Log) menu contains commands to start and stop session and transaction
  296. logging.  It also has an entry to dump the current screen image to the session
  297. log, which is only enabled when the session log is open.
  298.  
  299. @Section<Terminal Emulation>
  300.  
  301. Before you can transfer files, you have to establish a terminal connection
  302. with the other computer.  You don't have to give MacKermit any special command
  303. to do this, just start the program.  Assuming you have a physical connection,
  304. then the software will use it.  If you think you have a physical connection,
  305. but don't see any results, click on the @b(Settings) menu and select
  306. @b(Communications) to make sure you have the right speed and parity.  If you
  307. have to dial out to make the connection, you must do this yourself -- Mac
  308. Kermit won't do it for you.  Depending on the type of modem, you must either
  309. type dialing commands to it directly (like the Hayes ATDT command in the
  310. example in section @ref<-macstart>), or else dial the phone manually, wait for
  311. an answer and a carrier tone, and then put the modem in data mode.
  312.  
  313. Once you've made the connection, you can use MacKermit's terminal emulator,
  314. @index<VT102 Emulation>
  315. which conforms to ANSI standard X3.64, providing a subset of the features of
  316. the DEC VT102 terminal (a VT100 with line and character insert and delete
  317. functions added).  The functions provided are sufficient to allow MacKermit to
  318. act as a terminal for the EMACS full-screen editor as it exists on most
  319. timesharing systems, and for most host-@|resident display-oriented applications
  320. that expect to do cursor positioning and editing on the VT100 or VT102 screen,
  321. such as VAX TPU.  MacKermit does not currently support the following VT100/102
  322. functions:
  323. @Begin(Itemize,spread 0)
  324. Double height or double width lines
  325.  
  326. Blinking
  327.  
  328. 132 columns
  329.  
  330. DEC-style line wrapping
  331.  
  332. Control characters embedded in escape sequences
  333.  
  334. VT52 mode
  335. @End(Itemize)
  336. (this is not an exhaustive list)
  337.  
  338. The keyboard is set up by default as follows: If your Macintosh has a Control
  339. key (ie. an SE or II), Kermit uses it, and the Command (Fan, Cloverleaf) key
  340. can be used for keyboard equivalents for menus.  If your Mac does not have a
  341. Control key, then the Command key is used as the Control key.  The CAPS LOCK
  342. key forces all alphabetic characters to upper case.  The terminal emulator
  343. sends ESC (escape) when the @qq(`) (accent grave) key is pressed unshifted
  344. (even if your keyboard has an ESC key).  The character @qq(`) can be sent by
  345. typing Control (or Command) and the same key.  The Backspace key sends a
  346. Delete (Rubout) and Control-@|Backspace sends a Backspace.  On the original
  347. Mac keyboards, the main keypad Enter key sends a "short" (250ms) BREAK signal.
  348. The Mac+, Mac SE, and Mac II do not have a main keypad Enter key, so the BREAK
  349. function must be reassigned to another key.
  350.  
  351. @index<Key Redefinition>
  352. You can modify the keyboard layout any way you like, defining keyboard macros,
  353. defining or moving the Control and Escape keys, etc., using MacKermit's
  354. built-in key configuration features.  Older MacKermits (version 0.8 and
  355. earlier) came with a separate key configuration program called CKMKEY.  This
  356. should not be used, because it does not understand the format of the 0.9 and
  357. later keyboard configuration software.
  358.  
  359. MacKermit includes a mouse-controlled@index<Mouse> cursor positioning feature
  360. for use during terminal emulation.  If the "Mouse -> Arrow Keys" feature is
  361. turned on (via the @b[Terminal] entry of the @b[Settings] menu), then when the
  362. mouse button is pressed, the program acts as if you typed the VT100 keypad
  363. arrow keys to move the terminal cursor to where the mouse cursor is.
  364. MacKermit does this by sending the absolute strings for arrow keys,
  365. independant of what is bound to the actual arrow keys of the keyboard.
  366.  
  367. MacKermit sets the Mac hardware to do 8-bit data communication with no
  368. parity@index(Parity), and then correctly sets the parity bit of each character
  369. itself in software, as requested in the @b<Communication> settings menu.  This
  370. has the benefit of avoiding the problem of a machine which requires a
  371. different input parity than it sends back.  MacKermit will correctly receive
  372. all of the characters sent to it, no matter which parity they are.
  373.  
  374. To allow useful coexistence of desk accessories and Kermit, the terminal
  375. emulation window may be dragged using the drag bar.  If a desk accessory
  376. overlays the emulation window, the emulation window can be clicked upon to move
  377. it in front of the DA, and later dragged to reveal the hidden desk accessory so
  378. that it can be restored to the foreground.  The same thing can be done with
  379. Kermit's own remote response window as well.  Note that Kermit's terminal
  380. emulation window does not accept input when any other window is in the
  381. foreground.
  382.  
  383. MacKermit uses XON/XOFF (control-Q and control-S) flow control during
  384. terminal emulation and file transfer.  If the other system does not
  385. understand XON/XOFF, problems may result at high speeds.  The terminal
  386. emulator can normally keep up at 9600 baud, and has a very large input
  387. buffer, but after several continuous scrolling screens at this speed, some
  388. characters may be lost.  When running at high baud rates on a system that
  389. does not understand XON/XOFF flow control, either keep your terminal in
  390. page mode, use a text paging program such as Unix "more", or view text with
  391. a non-@|scrolling screen editor.  Also, don't drag the terminal emulation
  392. window while characters are arriving; if you do, the characters may be lost
  393. and the display may become confused.
  394.  
  395. @index(Session Log)@index(Raw Download)
  396. During terminal emulation, the characters displayed on the screen may also
  397. be saved on the disk.  This allows you to record interactions with the
  398. remote system, or to "capture" files that you can't transfer with Kermit
  399. protocol, for example when the remote system does not have a Kermit program.
  400. Use the @b<Log> menu, and choose session logging to activate this feature.
  401. The result goes into a file called "Kermit Session" in the current folder,
  402. which is always appended to, rather than overwritten.  To create a new session
  403. log, delete or rename the old one first.
  404.  
  405. The following features are missing from the MacKermit terminal emulator,
  406. and may be added in subsequent releases:
  407. @Begin(Itemize,Spread 0)
  408. Restoration of character attributes such as underlining or highlighting.
  409.  
  410. Cutting text from screen to clipboard.
  411.  
  412. Transmission of raw text to host (e.g. pasting to screen).
  413.  
  414. Screen rollback.
  415.  
  416. Screen resizing.
  417.  
  418. Explicit modem or dialer control.
  419.  
  420. Login scripts.
  421.  
  422. Printer support.
  423.  
  424. Ability to use the printer port for terminal emulation.
  425.  
  426. A way to disable XON/XOFF flow control, or select other flow controls.
  427. @End(Itemize)
  428.  
  429. @Section(File Transfer)
  430.  
  431. Like most Kermit programs, MacKermit allows you to send and receive text or
  432. binary files singly or in groups.  It will interact with a remote Kermit
  433. server, and it can act as a server itself.  However, due to the unique nature
  434. of the Macintosh file system, there are some special considerations:
  435. @Begin(Itemize)
  436. @begin<multiple>
  437. @u<Mode> - Text or Binary@index<Binary Files>.  Binary means the data is sent
  438. or stored without modification.  Text means that every carriage return
  439. character (CR) in a Macintosh file is translated to a carriage-return-linefeed
  440. (CRLF) sequence when sending, and every CRLF in an incoming file is turned
  441. into a CR when stored on the Mac disk.  A text file is produced when you save
  442. a file from MacWrite or other applications using the "text only" option; text
  443. files are not associated with any particular Macintosh application and can be
  444. sent in a useful fashion to other kinds of computers.
  445.  
  446. A word of caution about Macintosh text files: The Macintosh supports an
  447. extended version of ASCII@index<Extended ASCII>, with characters like accented
  448. and umlauted vowels in the 128-255 range.  These characters allow
  449. representation of Roman-based languages other than English, but they do not
  450. follow any of the ISO standards for extended character sets, and thus are only
  451. useful on a Mac.  When transferring text files, you should ensure that either
  452. there are no extended characters in the file, or that the other system can
  453. understand the Mac's 8-bit characters.
  454. @end<multiple>
  455.  
  456. @u<Fork> - Data or Resource.  Macintosh files may have two
  457. "forks"@index(Fork).  The data fork contains data for an application; the
  458. resource fork contains icons, strings, dialog boxes, and so forth.  For
  459. instance, a MacWrite document contains text and formatting information in the
  460. data fork, and fonts in the resource fork.  For applications, the executable
  461. code is stored in the resource fork.
  462. @End(Itemize)
  463.  
  464. File transfer is initiated when you select @b(Send file...), @b(Receive
  465. File...), or @b(Get file from server...) from MacKermit's @b(File) menu.
  466.  
  467. File transfers can be canceled by clicking on the Cancel File or Cancel Group
  468. buttons.  These will always work when sending.  When receiving, they will work
  469. if the opposite Kermit honors this (optional) feature of the protocol.  There
  470. is also an "emergency exit" from any protocol operation, which can be taken at
  471. any time by typing "Command-@q(.)" -- that is, hold down the Command (Fan,
  472. Cloverleaf) key and type period.
  473.  
  474. The progress of file transfer operations can be logged into a Macintosh file
  475. called a "transaction log".  This log will show the names of the files
  476. transferred, the date and time, and the completion status.  This feature is
  477. useful with long unattended transfers -- you can come back later and read the
  478. transaction log to find out what happened.  The transaction log is called
  479. "Kermit Log".
  480.  
  481. The current version of Mac Kermit can only send one fork of a file at a time.
  482. When a file has two forks, there is no provision for sending both forks
  483. together.  This restriction may be lifted in future releases of MacKermit, for
  484. example by converting applications to MacBinary@index<MacBinary> format during
  485. transmission.
  486.  
  487. @subsection(Sending Files)
  488. To send files, first put the remote Kermit in server mode, or else give it the
  489. RECEIVE command.  Then use the mouse to select @b(Send file...) from the
  490. @b(File) menu.  This will give you a MacKermit file-open box, which includes
  491. the standard Macintosh dialog items -- a file list, Disk and Eject buttons,
  492. etc.  You can either send one file at a time, by clicking on its name in the
  493. file list, or send the entire contents of the current HFS folder (for HFS
  494. disks only, of course).  Clicking the Disk button will switch the file list to
  495. another physical disk.  If desired, you can type an alternate name to send the
  496. file under.  When you select a file, MacKermit examines its type; if the type
  497. is APPL, then MacKermit expects to send the resource fork in binary mode,
  498. otherwise the data fork in text mode.  The Mode and Fork radio buttons will
  499. display these choices; you may change them before clicking the Send button.
  500.  
  501. @subsection(Receiving Files)
  502. You can receive or get multiple files, providing the opposite Kermit is
  503. capable of sending multiple files in a single transaction (most are).  To
  504. receive files, first give the remote Kermit a SEND command and then select
  505. @b(Receive file...) from the @b(File) menu.  To get files from a server,
  506. first put the remote Kermit into server mode, then select the @b(Get file from
  507. server...) option from the @b(File menu), and type in the name of the file you
  508. want to get, or a wildcard designator for multiple files, in the remote
  509. system's filename syntax.
  510.  
  511. As each file arrives at the Mac, it will be decoded according to the current
  512. mode (text or binary), and stored in the default fork (data or resource).  The
  513. file names will be either the names the files arrive with (overwriting
  514. existing files of the same names) or new unique names (when name conflicts
  515. occur), according to the current default for name collisions.  You may also
  516. elect to perform an "attended" receive, in which you have an opportunity to
  517. override file defaults on a per-file basis (do this in the @b(Protocol)
  518. section of the @b(Settings) menu).  But attended operation must be used with
  519. caution -- if you take too long (more than about a minute) to execute an
  520. incoming file's dialog box, the opposite Kermit could time out and terminate
  521. the transaction.  If this happens, tell the opposite Kermit to send again and
  522. try again with the receive dialog.
  523.  
  524. The folder for new files is the same as the location of the settings file, or
  525. if no settings file was used then the new files appear on the desktop.  If you
  526. are transferring a lot of files and want to keep them together, create a
  527. folder, drag the settings file into it, and double click on the settings file;
  528. all created files will appear in that folder.
  529.  
  530. @section(Remote Commands)
  531.  
  532. When connected to a Kermit server, MacKermit is capable of issuing special
  533. file management and other commands to it.  The @b(Remote) menu contains these
  534. commands.  You may request directory listings, you can delete files, change
  535. directories, etc, on server's machine.  The response from these commands (if
  536. any) is displayed in a special pop-up window.  Responses to multiple Remote
  537. commands are separated by a dashed line.  The response window can be scrolled,
  538. sized, and positioned, and can be hidden by clicking the menu item "@b(Hide
  539. Response)" or the window's go-away box; all text remains intact and will be
  540. appended to the next time you do a Remote command; it can also be brought to
  541. the foreground by clicking the @b(Show Response) menu item.  Note that typein
  542. to the terminal emulator will not take effect when the response window -- or
  543. any other window (such as a desk accessory) -- is up front.  This is not a
  544. bug, but a feature of the Macintosh user interface guidelines.
  545.  
  546. If the response buffer gets too full (greater than 30,000 characters),
  547. MacKermit will remove enough text from the beginning of the buffer, in 512 byte
  548. chunks, to make it less than 30,000 characters again.
  549.  
  550. A Remote command can be canceled by taking the Emergency Exit (Command-@q<.>).
  551. To disengage from the remote Kermit server, click on @b(Bye) or @b(Finish) in
  552. the @b(Remote) menu.
  553.  
  554. @section(Server Operation)
  555.  
  556. MacKermit may itself act as a Kermit server.  Just set the desired parameters
  557. in the @b(Settings) menu, then click on @b(Be a Server) in the @b(Remote)
  558. menu.  The MacKermit server can respond to SEND, GET, REMOTE DIRECTORY,
  559. FINISH, and BYE commands.  You can send single or multiple files to a
  560. MacKermit server, and you can get a single file from it by name.  You can also
  561. get all the files in the current folder by using a colon (@qq<:>) as the file
  562. specification in the GET command:
  563. @example<GET :>
  564. If you give the FINISH command, MacKermit will return to terminal mode.  If
  565. you give the BYE command, the Macintosh will reboot itself.
  566.  
  567. You can take MacKermit out of server mode from the Mac keyboard by typing the
  568. emergency exit sequence, Command-dot.
  569.  
  570. @section(Settings)
  571. @label<-macset>
  572.  
  573. You can change File, Communications, Protocol, Terminal, Keyboard macros, and
  574. Keyboard modifier settings by using the @b(Settings) pull-@|down menu.  You can
  575. save and load these settings by invoking the appropriate selection in the
  576. @b(File) menu.  If the "bundle bit" has been correctly set on your version of
  577. MacKermit (it should be), then you can double-@|click on the resulting document
  578. to start MacKermit with those settings.
  579.  
  580. The @b(File) settings establish the defaults for file transfer:
  581. @Begin(Itemize)
  582. @u<Attended> versus @u<Unattended> operation for incoming files.
  583.  
  584. @u<Naming>: When doing @u(unattended) file reception, whether incoming
  585. files should supersede existing files of the same name, or a new
  586. unique name should be assigned to them.  If the latter, the new name
  587. is formed by adding a dot and a number to the end.  For instance, if a
  588. file called FOO exists and a file called FOO arrives, MacKermit will
  589. store the arriving file as FOO.1; if FOO.1 exists, then FOO.2, etc.
  590.  
  591. @u<Mode>: text or binary.  Used for received files only.  When sending,
  592. MacKermit tries to figure out an appropriate mode for the file being
  593. sent (but then lets you override it the Send File dialog).
  594.  
  595. @u<Fork>: which fork -- data or resource -- to send, or to store an incoming
  596. file into.
  597. @End(Itemize)
  598.  
  599. The @b<Communications> settings allow you to set the baud rate (anywhere
  600. between 300 baud and 57@q<.>6K baud, except 38@q<.>4K baud), and parity (odd,
  601. even, mark, space, or none).  When the parity is set to @u(none) the Macintosh
  602. uses an 8-bit-wide connection.  All other parity settings tell the Macintosh
  603. to use a 7-bit-wide connection, and to request 8th-bit prefixing@index<8th-bit
  604. Prefixing> when transferring 8-bit data.  If the remote host or the
  605. communication path uses any kind of parity, then you won't be able to transfer
  606. files successfully unless you tell MacKermit (and in most cases also the
  607. Kermit on the other end) about it.  Duplex is selected in the @b(Terminal)
  608. settings.
  609.  
  610. The @b<Protocol> settings allow you to set packet parameters for both incoming
  611. and outbound packets.  These include the block check type (1 or 2 character
  612. checksum, 3-character 16-bit CRC-CCITT), line turnaround handshake
  613. character (for file transfer with half duplex systems), packet start and
  614. end characters, padding, packet length, timeout interval, and packet length.
  615. Characters are specified by entering their ASCII value in decimal, e.g. 1
  616. for Control-A, 13 for Control-M (Carriage Return), etc.  The RECEIVE
  617. parameters are conveyed by MacKermit to the other Kermit.  For instance,
  618. if you set the receive-packet-length to 500, MacKermit will tell the other
  619. Kermit to send 500-character packets.  The SEND parameters are used to
  620. override negotiated values, and need rarely be used.
  621.  
  622. @index<Long Packets>
  623. Long packets are selected by setting the RECEIVING packet length between 95
  624. and 1000.  Normally, you should not change the sending length because
  625. MacKermit, and most other Kermits, will configure themselves correctly.
  626. Note also that the fastest file transfers will happen with long packets in
  627. the range of 300-500.  Very long packets actually end up being much slower,
  628. because the operating systems in both the Mac and the other machine have to
  629. do more work to cope with such long inputs, and, under noisy conditions,
  630. the probability is higher that a longer packet will be struck by noise, and
  631. will take longer to retransmit.
  632.  
  633. The @b<Terminal> settings let you modify the characteristics of the VT102
  634. emulator, such as auto-linefeed, autowrap, autorepeat keys, block vs underline
  635. cursor, blinking vs steady cursor, inverted screen (reverse video), and smooth
  636. scrolling.  There is also a "visible bell@index<Bell>" for those who can't
  637. hear the audible bell produced upon receipt of a Control-G, and an option to
  638. display control characters visibly by showing their numeric ASCII values (in
  639. decimal) in a single character cell.  If local echo is needed, as in
  640. half-duplex connections, that must be specified here also.
  641.  
  642. @Section(Settings Files)
  643. @label<-macsfile>
  644.  
  645. @index(Settings Files)@index(MacKermit Settings Files)
  646.  You can start MacKermit with all its "factory settings" by double clicking on
  647. the MacKermit icon.  Factory settings are designed for direct communication
  648. with most other microcomputers, DEC minis and mainframes, etc: 9600 bps, no
  649. parity, XON/XOFF, remote echo, etc.  You can change the communication,
  650. protocol, file, keyboard, and terminal settings by going through the options
  651. in the @b(Settings) menu.  Once you have set all parameters as desired, you
  652. can save your settings in a "MacKermit settings file" by selected "@b(Save
  653. Settings...)" from the @b(File) menu.  A settings file is, in Macintosh
  654. terminology, a "MacKermit document".  You'll recognize it because it looks
  655. like a dog-eared piece of paper with the MacKermit icon superimposed.  You can
  656. have more than one settings file.
  657.  
  658. There are two ways to use a settings file.  First, you can double-click on it,
  659. just as you can double-click on a MacWrite document to start up MacWrite to
  660. edit a particular file.  This method starts up MacKermit with all the saved
  661. settings.  The other method is to click on the "@b(Load Settings...)" option
  662. in the @b(File) menu from inside MacKermit.  This lets you change settings
  663. without leaving and restarting the program.  @b(Load Settings...)  shows all
  664. MacKermit settings files in the selected folder.  Opening one of them loads
  665. all its settings, removing all current settings.
  666.  
  667. You can "edit" a MacKermit settings file by loading it, going through the
  668. @q(Settings) menu, and then saving the settings either in a new file, or
  669. overwriting the same file.
  670.  
  671. As distributed by Columbia, Mac Kermit comes with two settings files.  One is
  672. called "Normal Settings", and is pretty much identical to Mac Kermit's factory
  673. settings.  The other is "IBM Mainframe Linemode Settings".  It selects mark
  674. parity, local echo, XON half-duplex line turnaround handshake.  You can
  675. use these files as-is, customize them for your own environment, or create new
  676. settings files for all the different kinds of systems that you use.
  677.  
  678. @Section<Reconfiguring the Keyboard>
  679.  
  680. @index(Key Redefinition)
  681. Beginning with version 0.9, MacKermit has keyboard configuration functions
  682. built in.  These are accessed through the @b[Set Key Macros] and the @b[Set
  683. Modifiers] entries in the @b[Settings] menu.
  684.  
  685. The Macintosh keyboard is composed of normal keys and modifier keys.
  686. Modifier keys are those keys that, when held down, change the meaning of
  687. other keys.  On the Mac these are: SHIFT, CAPS LOCK, OPTION, CONTROL (only
  688. on the Mac II and SE), and COMMAND (also known as APPLE, CLOVER, or FAN).
  689. Normal keys are the letters, numbers, special symbols, arrow keys, space
  690. bar, and function keys.  Only one normal key can be typed at a time, but
  691. one or more modifier keys can be pressed down along with it.
  692.  
  693. When you type a key, Kermit reads both the ASCII value, and the
  694. keyboard-independent scan code for that key.  Kermit looks in its table of key
  695. macros to see if there is a macro for this combination of key and modifiers,
  696. and if so sends the macro.  If there is no macro, Kermit then looks in its
  697. modifier table to see if any of the modifiers do special things to the
  698. character; if so, it does these to the character.  Finally, Kermit sends the
  699. character.  In the normal case when there is no macro and no modifiers apply,
  700. the character sent is simply the ASCII value for that character.
  701.  
  702. It is important to keep in mind that if the parity setting is something other
  703. than @u[none], the high (8th) bit will be stripped off of the characters when
  704. they are transmitted.  Since most systems do not understand characters in the
  705. range 128 -- 255 (decimal), you should avoid using the Apple extended
  706. characters (accented vowels, for example) during terminal connection.
  707.  
  708. @SubSection<Defining Key Macros>
  709.  
  710. To define a new key macro, select the @b[Key Macros] entry.  A dialog window
  711. will appear, asking you to press the key to define.  Type the key (including
  712. any of the modifiers).  A new dialog will appear, with an editable text field
  713. in it.  Enter the definition for the key here.  Your definition may be up to
  714. 255 characters long, and can include all of the control characters (including
  715. NUL).  Special characters can be included in the macro by entering a @qq<\>
  716. (backslash), followed by up to 3 @i<octal> (base 8) digits for the value (just
  717. like in the C programming language).  For example, an ASCII NUL (value 0)
  718. would be written as @qq<\000>, carriage return (ASCII 13) would be written
  719. @qq<\015> (1 x 8 + 5 = 13).  Also, control characters may be entered with a
  720. backslash, followed by a caret (or circumflex, @qq<^>), followed by the
  721. corresponding letter.  Thus a Control-G (value 7) could be entered as
  722. @qq<\007>, @qq<\^G>, or @qq<\^g>.  To include a literal backslash in a
  723. definition, type in two of them: @qq<\\>.
  724.  
  725. @index<BREAK>
  726. BREAK conditions are also programmable as macros.  If the entire macro the
  727. string is @qq<\break>, then typing the defined key will send a short (1/4
  728. second) break.  A long (3.5 second) BREAK is defined with @qq<\longbreak>.
  729. Note that a macro can define either a BREAK, or a string of normal characters,
  730. but not both.
  731.  
  732. @SubSection<Defining Key Modifiers>
  733.  
  734. Skip ahead to the next section if you already know about things like SHIFT,
  735. CAPS LOCK, CONTROL, and META.
  736.  
  737. On a typewriter the only modifier key is SHIFT.  Typing a character with no
  738. modifier key depressed selects a lowercase letter or the character printed on
  739. the lower face of the keytop (say, the digit "4").  Typing a character with
  740. SHIFT depressed selects an uppercase letter or the character printed on the
  741. upper face of the keytop (say, a dollar sign).  Some keyboards also have a
  742. SHIFT LOCK key, which stays down once pressed and pops up the next time it's
  743. pressed; its operation is equivalent to holding down SHIFT.  And some keyboards
  744. have a CAPS LOCK key which operates like SHIFT LOCK, but only upon letters.
  745.  
  746. Computer terminals also have a modifier key called CONTROL (or CTRL).  Its
  747. function is a little less obvious: it is intended to produce one of the 33
  748. characters in the "control range" of the ASCII alphabet.  Control
  749. characters are not graphic -- they are intended for use as format effectors
  750. (like carriage return, formfeed, tab, backspace), for transmission control,
  751. or for device control.  The remaining 95 characters -- letters, digits,
  752. punctuation, and space -- are the graphic characters.  When a character is
  753. typed with the CONTROL modifier pressed, its "control equivalent" (if any) is
  754. transmitted.  By convention, the control equivalent of A is Control-A, B is
  755. Control-B, etc, and there are also seven special control characters
  756. generally associated with punctuation characters or special keys.  For the
  757. "alphabetic" control characters Control-A through Control-Z, SHIFT or CAPS
  758. LOCK modifiers are ignored; for the others, operation varies from terminal
  759. to terminal.
  760.  
  761. The SHIFT and CONTROL modifiers allow all 128 ASCII characters to be sent
  762. from a normal typewriter-like keyboard that has about 50 keys.  However,
  763. certain host-resident computer applications -- notably the full screen text
  764. editor EMACS and its descendents -- can be used to greater advantage with a
  765. 256 character 8-bit alphabet (EMACS responds to single-character commands,
  766. and the more characters a terminal can send, the more commands are directly
  767. available).
  768.  
  769. @index<META Key>
  770. For this purpose, some terminals also provide a META modifier key.  This key
  771. simply causes the high-order ("8th") bit of the selected 7-bit ASCII value to
  772. be set to 1 upon transmission.  This can only work when the connection is
  773. 8-data-bits-@|no-parity.  When parity is in use, EMACS allows a sequence of
  774. two 7-bit ASCII characters to represent a single meta character.  The
  775. advantage of having a real META modifier key is that it can be held down while
  776. the actual key is struck repeatedly or even autorepeats, whereas a use of a
  777. "meta prefix" such as <escape> requires much more typing.  To illustrate,
  778. suppose META-F is the command to go forward one word.  If you want to execute
  779. this operation repeatedly, just hold down META and F and let it autorepeat.
  780. If you don't have a META key, then you'd have to type
  781. <escape>F@|<escape>F@|<escape>F..., etc.
  782.  
  783. A common problem faced by computer users who switch from one terminal or PC
  784. to another is the placement of the modifiers and other special keys.
  785. DEC, IBM, Apple, and other manufacturers consistently move these keys
  786. around on new models of their keyboards.  MacKermit allows you to assign
  787. any of various functions to any of the Mac's modifier keys, and to assign
  788. any desired character or character sequence to the regular keys, so that
  789. you can tailor the layout of your Mac's keyboard to suit your taste.
  790.  
  791. @subsection<Modifiers Dialog>
  792.  
  793. To change the action of any of the modifier keys, select @b[Modifiers]
  794. from the @b[Settings] menu.  A dialog will appear that looks roughly
  795. like the one in Figure @ref<-macmkey> (the @qq(%) represents
  796. the Apple or Clover key).
  797.  
  798. @Begin(Figure)
  799. @bar()
  800. @blankspace(1)
  801. @begin(example,group)
  802.      Modifier Pattern:  -->   Modification:
  803.  
  804.   Ctrl Opt Lock Shift  %      Unmodify Caps Ctrl Meta Prefix string:
  805.                                                        ____________
  806.   [X]  [ ] [ ]  [ ]   [ ]   |   [ ]    [ ]  [X]  [ ]  [____________]
  807.   [ ]  [ ] [ ]  [ ]   [X]   |   [ ]    [ ]  [X]  [ ]  [____________]
  808.   [ ]  [X] [ ]  [ ]   [ ]   |   [x]    [ ]  [ ]  [ ]  [@ux<\033        >]
  809.   [ ]  [ ] [ ]  [ ]   [ ]   |   [ ]    [ ]  [ ]  [ ]  [____________]
  810.  
  811.                 (Cancel)   (Help)   ( OK )
  812. @end(example)
  813. @caption(MacKermit Key Modifier Dialog)
  814. @tag<-macmkey>
  815. @bar()
  816. @End(Figure)
  817.  
  818. The check boxes are divided into rows, each one describing a modification.
  819. The left half of each row describes the modifier combination to look for; a
  820. checked box means that this key is down, and an unchecked box means "don't
  821. care".  Note that there is no way to specify a key being up, and lines with
  822. nothing checked on the left side will be ignored; the character will be
  823. modified in the normal Macintosh way.
  824.  
  825. The right half describes what modification to do to the characters.  The
  826. Unmodify modification says "make this the character that would be sent from the
  827. same key with no modifer keys pressed".  In other words, un-Option, un-Caps,
  828. un-Control, and un-Shift this character.  The Caps modification translates all
  829. letters to upper case, Ctrl makes the letter a contol character, Meta sets the
  830. high (8th) bit on the character, and if a Prefix string is present, it is sent
  831. before the character is.
  832.  
  833. @i<Hints about modifiers:>
  834. @begin<itemize>
  835. Beware of the Option key.  It changes the value of any characters you use with
  836. it.  If you type Option-F, the Mac will send a D, if you type Option-B, the
  837. Mac will send a @qq(:), etc.  If you want to use the option key as a modifier,
  838. be sure to check the "Unmodify" box.
  839.  
  840. To use MacKermit with a version of EMACS that does not accept 8-bit Meta
  841. characters, define a key, like Option, to be unmodified, with a prefix string
  842. of @q(\033) (ASCII Escape), as in Figure @ref<-macmkey>.  Then you can hold
  843. down Option and type F (or any other key) repeatedly, or let it autorepeat,
  844. and MacKermit will send the correct prefix-Meta sequence.
  845.  
  846. When interpreting a keystoke, MacKermit checks the list of modifiers from
  847. top to bottom, applying the first one that matches.  This means that if you
  848. want a different modifier for Command-Option and just plain Command, you
  849. must put the definition for Command-Option first in the list.
  850. @end<itemize>
  851.  
  852. @section<Bootstrapping>
  853. @index<Bootstrapping MacKermit>
  854. This section applies if you do not have a MacKermit diskette, but MacKermit is
  855. available for downloading from some other computer.
  856.  
  857. MacKermit is distributed in source form for building on a Macintosh,
  858. running Apple's Macintosh Programmers Workbench (in MPW C), in
  859. @index<Binhex> @q(.HQX) "BinHex 4" form, and sometimes also as a binary
  860. resource file.  Those who want to work from the source are referred to the
  861. file @q(CKMKER.BLD) for instructions.
  862.  
  863. If you're downloading, it's best to work with @q<CKMKER.HQX>, a textual
  864. encoding of the MacKermit application.  Download this using any technique
  865. available to you -- an old release of Kermit, an Xmodem implementation, even
  866. raw screen capture.  Then run @index<BinHex> BinHex (version 4) to convert it
  867. into a working application (select @b(Upload -> Application) from the @b(File)
  868. menu).  Eveything will be set up correctly -- icons, forks, etc.
  869.  
  870. If you don't have the @q<.HQX> file available, but you do have access to the
  871. binary resource file (its name will be @q(CKMKER.RSRC), @q(ckmker.rsrc),
  872. @q(CKMKER.RSR), @q(ckmker.rsr), @q(%ckmker) or some variation on these,
  873. depending on what system it's stored on and how it got there), AND if you have
  874. "MacPut" on your system and MacTerminal on your Mac, AND if you have an
  875. 8-bit-wide (no parity) data path between your Mac and your system, then you
  876. can use MacPut to download the binary resource file to your Mac using
  877. MacTerminal's "MacBinary" format (a variant of XMODEM).  After doing this you
  878. must use a program such as @index<Setfile> SetFile or @index<ResEdit> ResEdit
  879. on the Mac to set the author to KR09, the type to APPL, and turn on the bundle
  880. bit.  Do not bother with the CKMKEY program, as it is not used with newer
  881. MacKermits.  If you have an earlier release of MacKermit, you may use it in
  882. place of MacTerminal and MacPut.
  883.  
  884. @section(Differences Between Versions 0.8 and 0.9)
  885.  
  886. MacKermit 0.8(34) runs on the 128K Mac, the 512K Mac, and the Mac Plus,
  887. but not on the Macintosh II or SE.  MacKermit 0.9(40) runs on all Macs except
  888. the 128K original.  You should use version 0.9 unless you have a 128K Mac.
  889.  
  890. The second major difference is that the program is has been translated into
  891. Apple MPW C, so that it can be edited, compiled, and built on the Macintosh
  892. itself.  This was done originally by Jim Noble of Planning Research
  893. Corporation, who converted MacKermit from SUMACC C (which had to be cross
  894. compiled on a UNIX system) to Megamax C.  Jim's version was converted to MPW
  895. C by Matthias Aebi, who also added most of the new features listed below.
  896. Paul Placeway integrated the program with the current (long packet) version
  897. of C-Kermit and added additional new features.
  898.  
  899. Besides these important differences, there were many other changes from version
  900. 0.8 to version 0.9, including:
  901. @begin<itemize,spread 0.2>
  902. The Cursor with open desk accessories now works correctly
  903.  
  904. Long packet support
  905.  
  906. New program icon
  907.  
  908. New settings files are no longer TEXT
  909.  
  910. Settings can now be written back to an already existing settings file
  911.  
  912. Key redefinition function built in to Kermit, no more CKMKEY
  913.  
  914. Server mode directory listing feature
  915.  
  916. Multifile (folder) send
  917.  
  918. Server "Delete" file command
  919.  
  920. Server "Space" command
  921.  
  922. Get whole folder content from the server with filename @qq<:>
  923.  
  924. Recognition of all the different Mac keyboards
  925.  
  926. Support of menu command keys (key macros)
  927.  
  928. Terminal settings dialog separated from communication settings
  929.  
  930. Non-transparent terminal mode
  931.  
  932. Display of statistics and protocol version to "About Kermit" dialog.
  933.  
  934. Parity problems fixed
  935.  
  936. Session logging
  937.  
  938. Transaction logging
  939.  
  940. Multifinder support
  941.  
  942. Additions to the VT102 emulator (smooth scrolling, etc)
  943.  
  944. Rearrangement of menus and displays
  945.  
  946. Program no longer hangs if remote response window gets too full
  947.  
  948. Program now works correctly on 64K ROM machines
  949.  
  950. A new manual
  951. @end<itemize>
  952. This manual applies in large part to version 0.8(34), except that the
  953. older version is missing the new features listed above, and it comes in two
  954. pieces: CKMKER and CKMKEY.  The CKMKEY program is used to program the
  955. keys, like the @b(Set Key Macros...) and @b(Set Modifiers) described in
  956. this manual, and creates a settings file which Kermit itself uses.  The old
  957. version only works well with early Macintosh keyboards.
  958.