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. If you have X11R4 or R5 and want to build
     the X11-based programs, use `configure --with-x'. Don't use the
     `--with-x' option unless you have X installed on your system.

     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.

     By default, the files will be installed in the directories
     `/usr/local/bin', `/usr/local/etc', and
     `/usr/local/etc/fingerdir'.  You can specify an installation
     prefix other than the default `/usr/local' by giving `configure'
     the option `--prefix=PATH'.  Alternately, you can do so by giving
     a value for the `prefix' variable when you run `make', e.g.,

          make prefix=/usr/gnu

     You can specify separate installation prefixes for
     architecture-specific files and architecture-independent files.
     If you give `configure' the option `--exec_prefix=PATH' or set
     the `make' variable `exec_prefix' to PATH, the package will use
     PATH as the prefix for installing programs and libraries.  Data
     files and documentation will still use the regular prefix.
     Normally, all files are installed using the regular prefix.

     The two `make' variables `prefix' and `exec_prefix' are used to
     construct the additional variables `bindir', `datadir',
     `statedir', and `daemondir' (unique to GNU Finger). These
     additional variables are the ones that actually govern where
     files are installed. They are constructed in the top-level
     `Makefile' and are passed down to the inferior makefiles in the
     subdirectories.

     You can tell `configure' to figure out the configuration for your
     system, and record it in `config.status', without actually
     configuring the package (creating makefiles).  To do this, give
     `configure' the `--no-create' option.  Later, you can run
     `./config.status' to actually configure GNU Finger 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 tells it to
     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 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 optionally 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.
          Apparently, some of the instructions here won't apply.

     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.

        * Restart the inetd daemon, 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. On many
     BSD systems, you can start it from `/etc/rc.local'. For exact
     details on how to do this, please refer to the server host's
     system documentation.

  9. 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.

