File: finger.info,  Node: Basic Installation,  Next: Configuration Files,  Up: Installation

Basic Installation
==================

Here are the steps that you will need to take in order to install GNU
Finger.

  1. Pick a machine which will be the local finger server for your
     network. Create a `clients' file, and install it in
     `/usr/local/etc/fingerdir' (or the EtcDir as specified in
     `config.h'). Put the names of all hosts that should report to the
     finger server in this file. Don't forget to include the finger
     server itself.

  2. For each client (the designated server is also a client), do the
     following,

  3. Change your working directory to be the top of the GNU Finger
     sources. For instance, if you have placed the source in
     `/src/gnu/finger' you would type `cd /src/gnu/finger'.

  4. In the source directory, type `make clean' and `./configure' if
     this host is different from the previous one.  If you're using
     `csh' on an old version of System V, you might need to type `sh
     ./configure' instead to prevent `csh' from trying to execute
     `configure' itself.

     The `configure' shell script attempts to guess correct values for
     various system-dependent variables used during compilation, and
     creates the Makefile(s) (one in each subdirectory of the source
     directory).  In some packages it creates a C header file
     containing system-dependent definitions.  It also creates a file
     `config.status' that you can run in the future to recreate the
     current configuration.

     Running `configure' takes a minute or two.  While it is running,
     it prints some messages that tell what it is doing.  If you
     don't want to see the messages, run `configure' with its
     standard output redirected to `/dev/null'; for example,
     `./configure >/dev/null'.

     To compile the package in a different directory from the one
     containing the source code, you must use a version of make that
     supports the VPATH variable, such as GNU make.  `cd' to the
     directory where you want the object files and executables to go
     and run `configure'. `configure' automatically checks for the
     source code in the directory that `configure' is in and in `..'.
      If for some reason `configure' is not in the source code
     directory that you are configuring, then it will report that it
     can't find the source code.  In that case, run `configure' with
     the option `--srcdir=DIR', where DIR is the directory that
     contains the source code.

     You can tell `configure' to figure out the configuration for your
     system, and record it in `config.status', without actually
     configuring the package (creating `Makefile' and perhaps a
     configuration header file).  To do this, give `configure' the
     `--no-create' option.  Later, you can run `./config.status' to
     actually configure the package for a particular host.  This
     option is useful mainly in `Makefile' rules for updating
     `config.status' and `Makefile'.  You can also give
     `config.status' the `--recheck' option, which makes it re-run
     `configure' with the same arguments you used before.  This is
     useful if you change `configure'.

     `configure' ignores any other arguments that you give it.

     If you want to install the GNU Finger configuration files
     somewhere other than `/usr/local/etc/fingerdir', then you should
     edit the files `./config.h' and `include/fingerpaths.h' now. 
     You need to specify the alternate locations of where the
     configuration files will be kept. If you want to include the
     unsupported code for mugshots, then you should now also choose
     one of the face formats, as well as edit `lib/Makefile.in',
     `lib/site/Makefile.in', and `src/Makefile.in' to compile and
     link in the files necessary.

     If your system requires unusual options for compilation or
     linking that `configure' doesn't know about, you can give
     `configure' initial values for some variables by setting them in
     the environment. In Bourne-compatible shells, you can do that on
     the command line like this:

          CC='gcc -traditional' DEFS=-D_POSIX_SOURCE ./configure

     The `make' variables that you might want to override with
     environment variables when running `configure' are:

     (For these variables, any value given in the environment
     overrides the value that `configure' would choose:)

    `CC'
          C compiler program. Default is `cc', or `gcc' if `gcc' is
          in your search path.

    `INSTALL'
          Program to use to install files. Default is `install' if
          you have it, `cp' otherwise.

     (For these variables, any value given in the environment is
     added to the value that `configure' chooses:)

    `DEFS'
          Configuration options, in the form `-Dfoo -Dbar ...'

    `LIBS'
          Libraries to link with, in the form `-lfoo -lbar ...'

  5. To build and/or install the GNU Finger executables and standard
     targets, issue one of the following commands:

    `make server'
          To build and install all executables, plus install the
          finger-specific server configuration files. Use this if the
          host is the designated finger server.

    `make client'
          To build all executables, but install only those used by
          the non-server clients. Use this unless the host is the
          designated finger server.

    `make all'
          To build all executables, but perform no installation.

     The above commands build `lib/libfinger.a' and the main programs
     in `src': `finger', `in.fingerd', and `in.cfingerd', as well as
     `fingerd' on the server.  If you want to, you can override the
     `make' variables `CFLAGS' and `LDFLAGS' like this:

          make CFLAGS=-O2 LDFLAGS=-s

  6. Modify the system configuration so that the client has (refer to
     the system documentation for details on how to do this on a
     particular system):

        * Entries in the system `services' file, or equivalent, which
          mentions the correct TCP port for `in.cfingerd' (port 2003)
          and `in.fingerd' (port 79). If port 2003 is already used by
          something else, then read the section on Configuration
          Files for details on how to specify a port other than 2003
          in the `/usr/local/etc/fingerdir/clients' file. A good name
          for the service is `cfinger'.

        * Entries in the system `inetd.conf' file, or equivalent,
          which contains references to `in.cfingerd' and `in.fingerd'.
          `in.fingerd' needs to be run with UID `root'.  Consult your
          system documentation for details on how to do this.
          `in.cfingerd' should be run with UID `root' on System V
          derivatives.

        * a `/usr/local/etc/fingerdir/serverhost' file which contains
          the name of the GNU Finger server host,

        * a `/usr/local/etc/fingerdir/mailhost' file which contains
          the name of the mail server to ask for user mail forwarding
          information and mailing list expansion, and

        * the inetd daemon restarted, so that server and user
          requests can be answered.

  7. When you have performed the above steps for each client, log
     onto the designated GNU Finger server.

  8. Start the server daemon, `fingerd'. You should arrange to have
     `fingerd' started every time the server host is rebooted. For
     exact details on how to do this, please refer to the server
     host's system documentation.

  9. If you chose to include the mugshots option, now might be a good
     time to install the mugshots.  But first, try getting a face
     from another site running GNU Finger!  For example, you might try
          `finger --face bfox@aurel.cns.caltech.edu'

 10. Modify the files `x-.help' and `x-.site' in
     `/usr/local/etc/fingerdir/targets' for your site.


Now you're all set! You might like to read through the section on
Configuration Files.

