Provided by: conserver-server_8.1.16-3_i386 bug

NAME

       conserver - console server daemon

SYNOPSIS

       conserver  [-7dDEFhinoRSuvV]  [-a  type] [-m max] [-M master] [-p port]
       [-b port] [-c cred] [-C config] [-P passwd] [-L logfile] [-O  min]  [-U
       logfile]

DESCRIPTION

       Conserver  is  the daemon that manages remote access to system consoles
       by multiple users via the console(1) client  program  and  (optionally)
       log  the  console  output.  It can connect to consoles via local serial
       ports, Unix domain sockets, TCP sockets (for terminal servers  and  the
       like), or any external program.

       When  started,  conserver reads the conserver.cf(5) file for details of
       each console.  The console type, logging  options,  serial  or  network
       parameters,  and  user  access levels are just a few of the things that
       can be specified.  Command-line  options  are  then  applied,  possibly
       overriding  conserver.cf(5)  settings.   Conserver categorizes consoles
       into two types: those it should actively manage, and  those  it  should
       just  know about, so it can refer clients to other conserver instances.
       If the master value of a console matches the hostname or ip address  of
       the   local  machine,  conserver  will  actively  manage  the  console.
       Otherwise, it’s considered  a  ‘‘remote’’  console  and  managed  by  a
       different  server.   Conserver forks a child for each group of consoles
       it must manage and assigns each process a port  number  to  listen  on.
       The  maximum  number  of  consoles managed by each child process is set
       using the -m option.  The console(1) client program  communicates  with
       the  master  console  server  process  to find the port (and host, in a
       multi-server  configuration)  on  which  the   appropriate   child   is
       listening.   Conserver  restricts connections from clients based on the
       host access section of its conserver.cf(5) file, restricts users  based
       on   the   console  access  lists  of  the  conserver.cf(5)  file,  and
       authenticates users against its  conserver.passwd(5)  file.   Conserver
       can also restrict clients using the tcp-wrappers package (enabled using
       --with-libwrap).  This authentication is  done  before  consulting  the
       conserver.cf(5) access list.

       When  Unix  domain  sockets  are  used  between  the  client and server
       (enabled using --with-uds),  authentication  checks  are  done  on  the
       hardcoded  address ‘‘127.0.0.1’’.  Automatic client redirection is also
       disabled (as if the  -R  option  was  used)  since  the  client  cannot
       communicate  with  remote  servers.   The  directory  used  to hold the
       sockets is checked to make sure it’s empty when the server starts.  The
       server  will not remove any files in the directory itself, just in case
       the directory is accidentally  specified  as  ‘‘/etc’’  or  some  other
       critical  location.   The  server  will  do  its best to remove all the
       sockets when it shuts down, but  it  could  stop  ungracefully  (crash,
       ‘‘kill  -9’’,  etc) and leave files behind.  It would then be up to the
       admin (or a creative startup script) to clean up the  directory  before
       the server will start again.

       Conserver  completely controls any connection to a console.  All escape
       sequences given by the user to console are passed to the server without
       interpretation.    The  server  recognizes  and  processes  all  escape
       sequences.

       The conserver parent  process  will  automatically  respawn  any  child
       process  that dies.  The following signals are propagated by the parent
       process to its children.

       SIGTERM   Close all connections and exit.

       SIGHUP    Reread the configuration file.  New consoles are  managed  by
                 forking   off  new  children,  deleted  consoles  (and  their
                 clients) are dropped, and changes to consoles  are  done  "in
                 place",  resetting the console port (bringing it down and up)
                 only when necessary.  The console name is used  to  determine
                 when  consoles  have been added/removed/changed.  All actions
                 performed by SIGUSR2 are also performed.

       SIGUSR1   Try to connect to any consoles marked as down.  This can come
                 in  handy  if you had a terminal server (or more) that wasn’t
                 accepting connections at startup and you  want  conserver  to
                 try to reconnect to all those downed ports.

       SIGUSR2   Close  and reopen all console logfiles and, if in daemon mode
                 (-d option), the error logfile  (see  the  -L  option).   All
                 actions performed by SIGUSR1 are also performed.

       Consoles   which  have  no  current  client  connection  might  produce
       important error messages.  With the -u option, these ‘‘unloved’’ errors
       are  labeled  with  a  machine name and output on stdout (or, in daemon
       mode, to the logfile).  This allows a live operator or an automated log
       scanner  to  find  otherwise  unseen  errors  by  watching  in a single
       location.

       Conserver must be run as root if it is to bind to a port under 1024  or
       if  it  must  read protected password files (like shadow passwords) for
       authentication (see conserver.passwd(5)).  Otherwise, it may be run  by
       any user, with -p used to specify a port above 1024.

       If  encryption has been built into the code (--with-openssl), encrypted
       client connections (without certificate exchanges) happen  by  default.
       To  add  certificate  exchanges,  use the -c option with the client and
       server.  For authentication of the certificates to  work,  the  signing
       certificate  must  be  properly trusted, which usually means the public
       portion is in OPENSSL_ROOT/ssl/certs (on both  the  client  and  server
       sides).    See   the  sample  self-signing  certificate  making  script
       contrib/maketestcerts for further clues.  To allow non-encrypted client
       connections  (in  addition to encrypted client connections), use the -E
       option.

OPTIONS

       Options may be given as separate arguments (e.g., -n -d)  or  clustered
       (e.g.,  -nd).  Options and their arguments may be separated by optional
       white space.  Option arguments containing spaces  or  other  characters
       special to the shell must be quoted.

       -7          Strip  the  high bit off of all data received, whether from
                   the console client or from the console device,  before  any
                   processing occurs.

       -atype      Set  the  default access type for incoming connections from
                   console clients: ‘r’ for refused  (the  default),  ‘a’  for
                   allowed,  or  ‘t’  for  trusted.  This applies to hosts for
                   which no matching entry is found in the access  section  of
                   conserver.cf(5).

       -bport      Set  the  base  port for children to listen on.  Each child
                   starts looking for free ports at port and  working  upward,
                   trying a maximum number of ports equal to twice the maximum
                   number of groups.  If no free ports are available  in  that
                   range,  conserver  exits.   By  default, conserver lets the
                   operating system choose a free port.

       -ccred      Load an SSL certificate and key from the PEM  encoded  file
                   cred.

       -Cconfig    Read  configuration  information from the file config.  The
                   default config may be changed at  compile  time  using  the
                   --with-cffile option.

       -d          Become a daemon.  Disconnects from the controlling terminal
                   and sends all output (including any debug  output)  to  the
                   logfile (see -L).

       -D          Enable  debugging  output,  sent  to  stderr.   Multiple -D
                   options increases debug output.

       -E          If  encryption  has  been  built  into  the  code  (--with-
                   openssl),  encrypted  client connections are a requirement.
                   This  option  allows  non-encrypted  clients  (as  well  as
                   encrypted clients) to connect to consoles.

       -F          Do  not  automatically  reinitialize  failed  (unexpectedly
                   closed) consoles.  If the console is a program (‘|’ syntax)
                   and  it  closes  with  a  zero  exit status, the console is
                   reinitialized regardless  of  this  option.   Without  this
                   option,  a  console  is  immediately  reopened, and if that
                   fails, retried every minute until successful.  This  option
                   has no effect on the -o and -O options.

       -h          Output a brief help message.

       -i          Initiate console connections on demand (and close them when
                   not used).

       -Llogfile   Log errors and  informational  messages  to  logfile  after
                   startup  in  daemon  mode (-d).  This option does not apply
                   when not running in daemon mode.  The default  logfile  may
                   be changed at compile time using the --with-logfile option.

       -mmax       Set the maximum consoles managed per process.  The  default
                   max may be changed at compile time using the --with-maxmemb
                   option.

       -Mmaster    Normally, this allows conserver to bind to a particular  IP
                   address  (like ‘127.0.0.1’) instead of all interfaces.  The
                   default is to bind to all addresses.  However,  if  --with-
                   uds   was   used   to   enable   Unix  domain  sockets  for
                   client/server communication, this points conserver  to  the
                   directory  where  it should store the sockets.  The default
                   master directory (‘‘/tmp/conserver’’)  may  be  changed  at
                   compile time using the --with-uds option.

       -n          Obsolete (now a no-op); see -u.

       -o          Normally,  a client connecting to a ‘‘downed’’ console does
                   just  that.    Using   this   option,   the   server   will
                   automatically  attempt  to  open (‘‘bring up’’) the console
                   when the client connects.

       -Omin       Enable  periodic  attempts  (every  min  minutes)  to  open
                   (‘‘bring  up’’)  all  downed consoles (similar to sending a
                   SIGUSR1).  Without this option,  or  if  min  is  zero,  no
                   periodic attempts occur.

       -pport      Set the TCP port for the master process to listen on.  This
                   may be either a port number or a service name.  The default
                   port,  ‘‘conserver’’  (typically  782),  may  be changed at
                   compile time using the --with-port option.  If the  --with-
                   uds option was used, this option is ignored.

       -Ppasswd    Read  the  table  of  authorized  user  data  from the file
                   passwd.  The default passwd may be changed at compile  time
                   using the --with-pwdfile option.

       -R          Disable  automatic  client  redirection  to other conserver
                   hosts.  This means informational commands like  -w  and  -i
                   will  only  show the status of the local conserver host and
                   attempts to connect to remote consoles will  result  in  an
                   informative message to the user.

       -S          Do  not  run  the  server,  just  perform a syntax check of
                   configuration file and exit with a non-zero value if  there
                   is  an  error.  Using more than one -S will cause conserver
                   to output various  information  about  each  console  in  5
                   colon-separated  fields,  enclosed  in  curly-braces.   The
                   philosophy behind the output is to provide  information  to
                   allow  external  detection  of multiple consoles access the
                   same physical port.   Since  this  is  highly  environment-
                   specific, conserver cannot do the check internally.

                   name     The name of the console.

                   master   The  hostname of the master conserver host for the
                            console.

                   aliases  The console aliases in a comma-separated list.

                   type     The type of console.  Values will be a ‘/’  for  a
                            local  device, ‘|’ for a command, ‘!’ for a remote
                            port, ‘%’ for a Unix domain socket, and ‘#’ for  a
                            noop console.

                   details  Multiple  values are comma-separated and depend on
                            the type of the console.  Local devices will  have
                            the   values   of   the   device   file  and  baud
                            rate/parity.  Commands will have string to invoke.
                            Remote  ports  will  have the values of the remote
                            hostname and port  number.   Unix  domain  sockets
                            will  have  the path to the socket.  Noop consoles
                            will have nothing.

       -u          Send unloved console output to conserver’s  stdout  (which,
                   in  daemon  mode,  is  redirected  to  the  logfile).  This
                   applies to all consoles  to  which  no  user  is  attached,
                   independent  of  whether  logging of individual consoles is
                   enabled via conserver.cf entries.

       -Ulogfile   Copy all console data  to  the  ‘‘unified’’  logfile.   The
                   output  is the same as the -u output, but all consoles, not
                   just those without a user, are logged.  Each line of output
                   is  prefixed  with the console name.  If a user is attached
                   read/write, a ‘*’ is appended to the console name, to allow
                   log  watching  utilites to ignore potential user-introduced
                   alarms.

       -v          Echo the configuration as it is being read (be verbose).

       -V          Output the version number and  settings  of  the  conserver
                   program and then exit.

PROTOCOL

       The  protocol  used to interact with the conserver daemon has two basic
       styles.  The first style is the initial line-based mode,  which  occurs
       before  connecting  to  a  console.  The second style is the character-
       based, escape-sequence mode, while connected to a console.

       The initial line-based mode begins the same for both the master process
       and  its children.  Upon a successful (non-rejected) client connection,
       an ‘‘ok’’ is sent.  The client then issues a  command  and  the  server
       responds  to  it with a result string (‘‘ok’’ being the sign of success
       for most commands).  The commands available are ‘‘help’’,  ‘‘ssl’’  (if
       SSL  was  built  into  the  code),  ‘‘login’’, and ‘‘exit’’.  Using the
       ‘‘login’’ command, the client authenticates and  gains  access  to  the
       extended  command  set.   This  is  where  the  master  process and its
       children differ.  The master process gives the client access to  global
       commands,  and  the  child  provides  commands for interacting with the
       consoles it manages.  The ‘‘help’’ command, in both cases, will provide
       a complete list of commands and a short description of what they do.

       The  second,  character-based,  style  of  interaction  occurs when the
       client issues the ‘‘call’’ command with a child process.  This  command
       connects the client to a console and, at that point, relays all traffic
       between the client and the console.  There  is  no  more  command-based
       interaction between the client and the server, any interaction with the
       server is done with the default escape sequence.

       This  is,  by  no  means,  a  complete  description   of   the   entire
       client/server  interaction.   It  is,  however,  a brief explanation in
       order to give a idea of what the program does.  See the  PROTOCOL  file
       in the distribution for further details.

FILES

       The  following default file locations may be overridden at compile time
       or by the command-line options described above.  Run  conserver  -V  to
       see the defaults set at compile time.

       /etc/conserver.cf        description  of  console  terminal  lines  and
                                client     host     access     levels;     see
                                conserver.cf(5).
       /etc/conserver.passwd    users   allowed   to   access   consoles;  see
                                conserver.passwd(5).
       /var/run/conserver.pid   the master conserver process ID
       /var/log/conserver       log of errors and informational messages
       /tmp/conserver           directory to  hold  Unix  domain  sockets  (if
                                enabled)

       Additionally, output from individual consoles may be logged to separate
       files specified in conserver.cf(5).

BUGS

       I’m sure there are bugs, I just don’t know where they are.  Please  let
       me know if you find any.

AUTHORS

       Thomas A. Fine, Ohio State Computer Science
       Kevin S Braunsdorf, Purdue University Computing Center
       Bryan Stansell, conserver.com

SEE ALSO

       console(1), conserver.cf(5), conserver.passwd(5)