ckccfg.txt

C-Kermit源码。是使用串口/Modem和网络通讯的程序

C-KERMIT CONFIGURATION INFORMATION                                   -*-text-*-

  As of C-Kermit version:  7.0.197
  This file last updated:  8 February 2000

  Frank da Cruz, Columbia University

  Copyright (C) 1985, 2000,
    Trustees of Columbia University in the City of New York.
    All rights reserved.  See the C-Kermit COPYING.TXT file or the
    copyright text in the ckcmai.c module for disclaimer and permissions.


DOCUMENTATION

  Frank da Cruz and Christine M. Gianone, "Using C-Kermit", Second Edition,
  1997, Digital Press / Butterworth-Heinemann, Woburn, MA, ISBN 1-55558-164-1
  US single-copy price: $44.95; quantity discounts available.  Available in
  computer bookstores or directly from Columbia University:

    The Kermit Project
    Columbia University
    612 West 115th Street
    New York NY  10025-7799  USA
    Telephone: [phone]
    Email: [e-mail]
    Web: http://www.columbia.edu/kermit/

  The CKERMIT2.TXT file contains supplementary info for C-Kermit 7.0 to be
  used until the 3rd edition of the manual is ready.


WHAT IS IN THIS FILE

This file is for C-Kermit developers.  It explains compilation options,
feature selection, and compilation problem-solving, as they (should) apply to
all versions of C-Kermit: UNIX, VMS, OS/2, and the rest.

CONTENTS

  0. OVERVIEW
  1. FILE TRANSFER
  2. SERIAL COMMUNICATION SPEEDS
  3. FULLSCREEN FILE TRANSFER DISPLAY
  4. CHARACTER SETS
  5. APC EXECUTION
  6. PROGRAM SIZE
     6.1. When Memory Is Not a Problem
     6.2. Removing Features
     6.3. Changing Buffer Sizes
     6.4. Other Size-Related Items
     6.5. Space/Time Tradeoffs
  7. DIALER SUPPORT
  8. NETWORK SUPPORT
     8.1. TCP/IP
	  8.1.1. Firewalls
	  8.1.2. Solving Compilation and Linking Problems
	  8.1.3. Enabling Host Address Lists
	  8.1.4. Enabling Telnet NAWS
          8.1.5. Enabling Incoming TCP/IP Connections
     8.2. X.25
     8.3. Other Networks
  9. EXCEPTION HANDLING
 10. SECURITY FEATURES
 11. ENABLING SELECT()
 12. I/O REDIRECTION
 13. FLOATING-POINT TIMERS
 14. SPECIAL CONFIGURATIONS
 APPENDIX I: SUMMARY OF COMPILE-TIME OPTIONS


0. OVERVIEW

This file gives more-or-less system-independent configuration information for
C-Kermit 5A and later.  The major topics covered include program size (and how
to reduce it), how to include or exclude particular features, notes on modem
and network support, and a list of C-Kermit's compile-time options.

For details about your particular operating system, consult the system-specific
installation instructions file:

  CK?INS.TXT

(? = U for UNIX, V for VMS, etc, for example, CKUINS.TXT for UNIX, CKVINS.TXT
for VAX/VMS, CKDINS.TXT for Data General AOS/VS, etc).  Also consult the
following files (use lowercase on UNIX):

  CKAAAA.TXT   Explanation of file naming conventions
  CKCPLM.TXT   C-Kermit "program logic manual"
  CK?KER.HLP   System-specific help file, if any
  CK?KER.MAK   System-specific build procedure
  CKCBWR.TXT   "Beware file": C-Kermit bugs, limitations, workarounds
  CK?BWR.TXT   System-specific "beware file"
  CKERMIT2.TXT User-level documentation for new features since "Using
               C-Kermit", 2nd Edition, was published.
  CKCnnn.TXT   Program edit history for edit nnn, e.g. CKC195.TXT.


1. FILE TRANSFER

Prior to version 7.0, C-Kermit was always built with the most conservative
Kermit file-transfer protocol defaults on every platform: no control-character
prefixing, 94-byte packets, and a window size of 1.

Starting in version 7.0, fast settings are the default for UNIX and VMS.  To
override these at compile time, include:

  -DNOFAST

in the C compiler CFLAGS.  Even with the fast defaults, it will drop down to
whatever window and packet sizes requested by the other Kermit, if these are
smaller, when sending files (except for control-character unprefixing, which
is not negotiated, and which is now set to CAUTIOUS rather than NONE at
startup).  C-Kermit's settings prevail when it is receiving.  To build with
fast defaults for other platforms, add:

  -DCK_FAST

to CFLAGS.


2. SERIAL COMMUNICATION SPEEDS

As of 6 September 1997, a new simplified mechanism for obtaining the list
of legal serial interface speeds is in place:

 . If the symbol TTSPDLIST is defined, the system-dependent routine
   ttspdlist() is called at program initialization to obtain the list.

 . This symbol should be defined only for C-Kermit implementations that
   have implemented the ttspdlist() function, typically in the ck?tio.c
   module.  See ckutio.c for an example.

 . TTSPDLIST is automatically defined in ckcdeb.h for UNIX.  Add the
   appropriate #ifdefs for other platforms when the corresponding
   ttspdlist() functions are filled in.

 . If TTSPDLIST is (or normally would be) defined, the old code (described
   below) can still be selected by defining NOTTSPDLIST.

The ttspdlist() function can obtain the speeds in any way that works.  For
example, based simply on #ifdef Bnnnn..#endif (in UNIX).  Although it might be
better to actually check each speed against the currently selected hardware
interface before allowing it in the array, there is usually no passive and/or
reliable and safe way to do this, and so it's better to let some speeds into
the array that might not work, than it is to erroneously exclude others.
Speeds that don't work are caught when the SET SPEED command is actually given.

Note that this scheme does not necessarily rule out split speed operation,
but effectively it does in C-Kermit as presently constituted since there are
no commands to set input and output speed separately (except the special
case "set speed 75/1200").

Note that some platforms, notably AIX 4.2 and 4.3, implement high serial
speeds transparently to the application, e.g. by mapping 50 bps to 57600 bps,
and so on.  See (e.g.) ckubwr.txt for examples.

That's the whole deal.  When TTSPDLIST is *not* defined, the following applies:

Speeds are defined in two places: the SET SPEED keyword list in the command
parser (as of this writing, in the ckuus3.c source file), and in the system-
dependent communications i/o module, CK?TIO.C, functions ttsspd() (set speed)
and ttgspd() (get speed).  The following speeds are assumed to be available
in all versions:

  0, 110, 300, 600, 1200, 2400, 4800, 9600

If one or more of these speeds is not supported by your system, you'll need
to change the source code (this has never happened so far).  Other speeds
that are not common to all systems have Kermit-specific symbols:

               Symbol       Symbol
  Speed (bps)  to enable    to disable
       50       BPS_50       NOB_50
       75       BPS_75       NOB_75
       75/1200  BPS_7512     NOB_7512
      134.5     BPS_134      NOB_134
      150       BPS_150      NOB_150
      200       BPS_200      NOB_200
     1800       BPS_1800     NOB_1800
     3600       BPS_3600     NOB_3600
     7200       BPS_7200     NOB_7200
    14400       BPS_14K      NOB_14K
    19200       BPS_19K      NOB_19K
    28800       BPS_28K      NOB_28K
    38400       BPS_38K      NOB_38K
    57600       BPS_57K      NOB_57K
    76800       BPS_76K      NOB_76K
   115200       BPS_115K     NOB_155K
   230400       BPS_230K     NOB_230K
   460800       BPS_460K     NOB_460K
   921600       BPS_921K     NOB_921K

and maybe some others...

The ckcdeb.h header file contains default speed configurations for the many
systems that C-Kermit supports.  You can override these defaults by (a)
editing ckcdeb.h, or (b) defining the appropriate enabling and/or disabling
symbols on the CC command line, for example:

  -DBPS_14400 -DNOB_115200

or the "make" command line, e.g.:

  make blah "KFLAGS=-DBPS_14400 -DNOB_115200"

Note: some speeds have no symbols defined for them, because they have never
been needed: 12.5bps, 45.5bps, 20000bps, etc.  These can easily be added if
required (but they will work only if the OS supports them).

IMPORTANT: Adding one of these flags at compile time does not necessarily mean
that you will be able to use that speed.  A particular speed is usable only if
your underlying operating system supports it.  In particular, it needs to be
defined in the appropriate system header file (e.g. in UNIX, cd to
/usr/include and grep for B9600 in *.h and sys/*.h to find the header file
that contains the definitions for the supported speeds), and supported by the
serial device driver, and of course by the physical device itself.

ALSO IMPORTANT: The list of available speeds is independent of how they are
set.  The many UNIXes, for example, offer a wide variety of APIs that are
BSD-based, SYSV-based, POSIX-based, and purely made up.  See the ttsspd(),
ttgspd(), and ttspdlist() routines for illustrations.

The latest entries in this horserace are the tcgetspeed() and ttsetspeed()
routines found in UnixWare 7.  Unlike other methods, they accept the entire
range of integers (longs really) as speed values, rather than certain codes,
and return an error if the number is not, in fact, a legal speed for the
device/driver in question.  In this case, there is no way to build a list of
legal speeds at compile time, since no Bnnnn symbols are defined (except for
"depracated, legacy" interfaces like ioctl()) and so the legal speed list must
be enumerated in the code -- see ttspdlist() in ckutio.c.


3. FULLSCREEN FILE TRANSFER DISPLAY

New to edit 180 is support for an MS-DOS-Kermit-like local-mode full screen
file transfer display, accomplished using the curses library, or something
equivalent (for example, the Screen Manager on DEC VMS).  To enable this
feature, include the following in your CFLAGS:

  -DCK_CURSES

and then change your build procedure (if necessary) to include the necessary
libraries, usually "curses", perhaps also "termcap" or "termlib":

  "LIBS= -lcurses -ltermcap"
  "LIBS= -lcurses -ltermlib"
  "LIBS= -lcurses"
  "LIBS= -ltermlib"

to pull in the required libraries.  "man curses" for further information, and
search through the makefile for "CK_CURSES" to see many examples.

Plus maybe you'll have to replace "curses" above by "ncurses".

There might still be a complication.  Some implementations of curses reserve
the right to alter the buffering on the output file without restoring it
afterwards, which can leave Kermit's command processing in a mess when the
prompt comes back after a fullscreen file transfer display.  The typical
symptom is that characters you type at the prompt after a file transfer do not
echo until you press the Return (Enter) key.  If this happens to you, try
adding

  -DCK_NEWTERM