ckccfg.doc

linux终端仿真程序

available on any UNIX system.  It is also available in OS/2, VMS, AOS/VS, VOS,
etc.  The TCP/IP support includes built-in TELNET negotiation handling.  To
select TCP/IP support, include -DTCPSOCKET in your makefile entry's CFLAGS, or
the appropriate variant (e.g. -DWOLLONGONG, -DMULTINET, -DEXCELAN, -DWINTCP,
etc).  The network support for TCP/IP and X.25 is in the source files CKCNET.H
and CKCNET.C, with miscellaneous SHOW commands, etc, in the various CKUUS*.C
modules, plus code in the CK*CON.C (CONNECT command) and several other modules
to detect TELNET negotiations, etc.

Within the TCPSOCKET code, some socket-level controls are included if
TCPSOCKET is defined in the C-Kermit CFLAGS and SOL_SOCKET is defined in
in the system's TCP-related header files, such as <sys/socket.h>.  These are

  SET TCP KEEPALIVE
  SET TCP LINGER
  SET TCP RECVBUF
  SET TCP SENDBUF

In addition, if TCP_NODELAY is defined, the following command is also
enabled:

  SET TCP NODELAY (Nagle algorithm)

See the user documentation for descriptions of these commands.

8.1.1. Firewalls

There exist various types of firewalls, set up allow separate users of an
internal TCP/IP network from the great wide Internet.  Of course, this could
be accomplished most easily and safely by simply not connecting the internal
network to the Internet, but in many cases some restricted forms of access are
needed.  Thus a "firewall" is set up to allow only authorized accesses.

One firewall method is called SOCKS, in which a proxy server allows users
inside a firewall to access the outside world, based on a permission list
generally stored in a file.  SOCKS is enabled in one of two ways.  First, the
standard sockets library is modified to handle the firewall, and then all the
client applications are relinked (in systems where linking is not dynamic)
with the modified sockets library.  The APIs are all the same, so the
applications do not need to be recoded or recompiled.

In the other method, the applications must be modified to call replacement
routines, such as Raccept() instead of accept(), Rbind() instead of bind(),
etc, and then linked with a separate SOCKS library.  This second method is
accomplished in C-Kermit by including -DCK_SOCKS in your CFLAGS, and also
adding:

  -lsocks

to LIBS, or replacing -lsockets with -lsocks (depending on whether the socks
library also includes all the sockets entry points).

Explicit firewall support can, in general, not be a standard feature or a
feature that is selected at runtime, because the SOCKS library tends to be
different at each site -- local modifications abound.

The ideal situation occurs when firewalls are supported by the first method,
using dynamically linked sockets-replacement libraries; in this case, all your
TCP/IP client applications will negotiate the firewall transparently.

8.1.2. Solving Compilation and Linking Problems

If you get a compilation error in CKCNET.C, with a complaint like
"incompatible types in assignment", it probably has something to do with the
data type your system uses for the inet_addr() function, which is declared
(usually) in <arpa/inet.h>.  Kermit uses "unsigned long" unless the symbol
INADDRX is defined, in which case "struct inaddr" is used instead.  Try adding
-DINADDRX to CFLAGS in your make entry, and if that fixes the problem, please
send a report to [e-mail].

Compilation errors might also have to do with the data type used for
getsockopt() and setsockopt() option-length field.  This is normally an int,
but sometimes it's a short, a long, or an unsigned any of those, or a size_t.
To fix the compilation problem, add -DSOCKOPT_T=xxx to the CFLAGS in your
makefile entry, where xxx is the appropriate type (use "man getsockopt" or
grep through your system/network header files to find the needed type).

8.1.3. Enabling Host Address Lists

When you give Kermit an IP host name, it calls the socket routine
gethostbyname() to resolve it.  gethostbyname() returns a hostent struct,
which might or might not not include a list of addresses; if it does, then
if the first one fails, Kermit can try the second one, and so on.  However,
this will only work if the symbol "h_addr" is a macro defined as
"h_addr_list[0]", usually in netdb.h.  If it is, then you can activate this
feature by defining the following symbol in CFLAGS:

  HADDRLIST

8.1.4. Enabling Telnet NAWS

TELNET Negotiation About Window Size (NAWS) support requires the ability to
find out the terminal screen's dimensions.  E.g. in UNIX, we need something
like ioctl(0, TIOCGWINSZ, ...).  If your version of Kermit was built with NAWS
capability, SHOW VERSIONS will include CK_NAWS among the compiler options.  If
it doesn't, you can add it by defining CK_NAWS at compile time.  Then, if the
compiler or linker complain about undefined or missing symbols, or there is no
complaint but SHOW TERMINAL fails to show reasonable "Rows =, Columns ="
values, then take a look at (or write) the appropriate ttgwsiz() routine.  On
the other hand, if CK_NAWS is defined by default for your system (in ckcnet.h),
but causes trouble, you can override this definition by including the -DNONAWS
switch on your CC command line, thus disabling the NAWS feature.

This appears to be needed at least on the AT&T 3B2, where in ckutio.c,
the routine ttgwsiz() finds that the TIOCGWINSZ symbol is defined but lacks
definitions for the corresponding winsize struct and its members ws_col
and ws_row.

The UNIX version of C-Kermit also traps SIGWINCH, so it can send a NAWS any
time the console terminal window size changes, e.g. when you stretch it with a
mouse.  The SIGWINCH-trapping code is enabled if SIGWINCH is defined (i.e. in
signal.h).  If this code should cause problems, you can disable it without
disabling the NAWS feature altogether, by defining NOSIGWINCH at compile time.

8.1.5. Enabling Incoming TCP/IP Connections

This feature lets you "set host * <port>" and wait for an incoming connection
on the given port.  This feature is enabled automatically at compile if
TCPSOCKET is defined and SELECT is also defined.  But watch out, simply
defining SELECT on the cc command line does not guarantee successful
compilation or linking (see section 11).

If you want to disable incoming TCP/IP connections, then build C-Kermit
with:

  -DNOLISTEN

8.1.6. Disabling "SET TCP" Options.

The main reason for this is because of header file / prototype conflicts at
compile time regardting get/setsockopt().  If you can't fix them (without
breaking other builds), just include the following in CFLAGS:

  -DNOTCPOPTS


8.2. X.25

X.25 support requires (a) a SUN, (b) the SunLink product (libraries and header
files), and (c) an X.25 connection into your SUN, or else Stratus VOS and the
appropriate X.25 development tools.

In UNIX, special makefile entries sunos4x25 and sunos41x25 (for SUNOS 4.0 and
4.1, respectively) are provided to build in this feature, but they only work
if conditions (a)-(c) are met.  To request this feature, include -DSUNX25 in
CFLAGS.

SUNX25 and TCPSOCKET can be freely mixed and matched.

8.3. Other Networks

Support for other networking methods -- NETBIOS, LAT, Named Pipes, etc --
is included in CK*NET.H and CK*NET.C for implementations (such as OS/2) where
these methods are supported.

Provision is made in the organization of the modules, header files, commands,
etc, for addition of new network types such as DECnet, X.25 for other systems
(HP-UX, VMS, etc), and so on.  Send email to [e-mail] if you are
interested in working on such a project.

9. EXCEPTION HANDLING

The setjmp/longjmp mechanism is used for handling exceptions.  The jump
buffer is of type jmp_buf, which almost everywhere is typedef'd as an array,
in which case you should have no trouble compiling the exception-handling
code.  However, if you are building C-Kermit in/for an environment where
jmp_buf is something other than an array (e.g. a struct), then you'll have
to define the following symbol:

  JBNOTARRAY

10. SECURITY FEATURES

Compiling with the NOPUSH symbol defined removes all the "shell escape"
features from the program, including the PUSH, RUN, and SPAWN commands, the
"!"  and "@" command prefixes, OPEN !READ, OPEN !WRITE, job control (including
the SUSPEND command), the REDIRECT command, shell/DCL escape from CONNECT
mode, as well as the server's execution of REMOTE HOST commands (and, of
course, the ENABLE HOST command).  Add NODISPO to also prevent acceptance of
incoming MAIL or REMOTE PRINT files.  For UNIX, also be sure to read
CKUINS.DOC about set[ug]id installation.  Additional restrictions can be
enforced when in server mode; read about the DISABLE command.

Compiling with NOCCTRAP prevents the trapping of SIGINT by Kermit.  Thus
if the user generates a SIGINT signal (e.g. by typing the system's interrupt
character), Kermit will exit immediately, rather than returning to its
prompt.

NOPUSH and NOCCTRAP together allow Kermit to be run from restricted shells,
preventing access to system functions.

11. ENABLING SELECT()

Kermit works best if it can do nonblocking reads, nondestructive input buffer
checking, and millisecond sleeps.  All of these functions are best
accomplished by the select() function, which, unfortunately, is not
universally available.  Furthermore, select() is required if incoming TCP/IP
connections are to be supported.

select() was introduced with Berkeley UNIX, rejected by AT&T for System V,
but is gradually creeping in to all UNIX versions (and other operating systems
too) by virtue of its presence in the sockets library, which is needed for
TCP/IP.  AT&T SVID for System V R4 includes select(), but that does not mean
that all SVR4 implementations have it.

Other alternatives include poll() and rdchk().  Only one of these three 
functions should be included.  The following symbols govern this:

  SELECT  Use select() (BSD, or systems with sockets libraries)
  CK_POLL Use poll()   (System V)
  RDCHK   Use rdchk()  (SCO)

If your system supports the select() function, but your version of C-Kermit
does not, try adding:

  -DSELECT

to the CFLAGS, and removing -DRDCHK or -DCK_POLL if it is there.  If you get
compilation errors, some adjustments to ck*tio.c and/or ck*net.c might be
needed; search for SELECT (uppercase) in these files (note that there are
several variations on the calling conventions for select()).

Various macros and data types need to be defined in order to use select().
Usually these are picked up from <types.h> or <sys/types.h>.  But on some
systems, they are in <sys/select.h>.  In that case, add the following:

  -DSELECT_H

to the CFLAGS to tell C-Kermit to #include <sys/select.h>.  A good indication
that you need to do this would be if you get compile-time complaints about
"fd_set" or "FD_SET" not being declared or defined.

WARNING: Some implementations of select() only work with file descriptors that
were created by socket() and opened by connect() or accept().  This is
evidently true on (at least) AOS/VS and BeOS.  Who knows where else.

----------------------------------------------------------------------
APPENDIX I: SUMMARY OF COMPILE-TIME OPTIONS

These are the symbols that can be specified on the cc command line, listed
alphabetically.  Others are used internally, including those taken from header
files, those defined by the compiler itself, and those inferred from the ones
given below.  Kermit's SHOW VERSIONS command attempts to display most of
these.  See ckcdeb.h and ckcnet.h for inference rules.  For example SVR3
implies ATTSV, MULTINET implies TCPSOCKET, and so on.

The following options are not included in all makefile entries, but they are