Provided by: burp_1.3.48-4_amd64 bug

NAME

       Burp - BackUp and Restore Program

SYNOPSIS

       burp [OPTIONS]

DESCRIPTION

       BackUp and Restore Program.

SERVER OPTIONS

       -c [path]
              Short  for 'config file'. The argument is a path to the config file. The default is
              /etc/burp/burp.conf.

       -n     No forking mode. The program will accept a single query, deal  with  it,  and  then
              exit. This is useful for debugging. Implies '-F'.

       -F     Foreground  mode.  The  server will fork into the background and run as a daemon if
              you do not give this option.

       -g     Generate initial CA keys and certificates, and then exit.

       -i     Print an index table of symbols that humans may see burp produce, and exit.

       -a s   Run this to connect to a running server to get a live monitor of the status of  all
              your backup clients. If your server config file is not in the default location, you
              will also need to specify the path with the '-c' option. The live monitor  requires
              ncurses support at compile time.

       -a S   Similar  to '-a s', but it prints the main status monitor summary screen to stdout.
              The intention is that a script can run this and email an administrator  the  output
              on  a  cron job. This doesn't require ncurses support. There are additional options
              that can be given with '-a S', listed below. These  enable  logs  and  contents  of
              backups to be listed whilst logged in on the server machine.

       ADDITIONAL SERVER OPTIONS TO USE WITH '-a S'

       -C [client]
              Limit the output to a single client.

       -b [number]
              Show listable files in a particular backup (requires -C).

       -z [file]
              Dump a particular log file in a backup (requires -C and -b).

       -d [path]
              Show a particular path in a backup (requires -C and -b).

CLIENT OPTIONS

       -a [b|t|r|l|L|v|D|e]
              Short  for  'action'.  The arguments mean backup, timed backup, restore, list, long
              list, verify, delete, or estimate, respectively.

       -b [number|a]
              Short for 'backup number'. The argument is a number, or 'a' to select all backups.

       -c [path]
              Short for 'config file'. The argument is a path to the config file. The default  is
              /etc/burp/burp.conf, or %PROGRAMFILES%\Burp\burp.conf on Windows.

       -C [client]
              Allows  you to specify an alternative client to list or restore from. Requires that
              the server configuration of the alternative client permits your client to do  this.
              See the 'restore_client' option.

       -d [path]
              Short  for  'directory'.  When  restoring, the argument is a path to an alternative
              directory to restore to. When listing, the argument is the directory to list.

       -f [path]
              Short for 'force overwrite'. Without this option set, a restore will not  overwrite
              existing files.

       -i     Print an index table of symbols that humans may see burp produce, and exit.

       -r [regex]
              Short  for 'regular expression'. The argument is a regular expression with which to
              match backup files. Use it for lists and restores.

       -s [number]
              For use with restores - strip a number of leading path components.

       -j     Format long file listing as JSON.

       -x     For Windows clients only - do not use the Windows VSS API  on  restore.  Give  this
              option when you are restoring a backup that contains no VSS information.

EXAMPLES

       burp -a b
              Runs a backup.

       burp -a l
              Lists the available backups and dates.

       burp -a l -b 1
              Lists all the files in backup number 1.

       burp -a l -b 1 -l /dev/null
              Lists all the files in backup number 1 without extra debug info.

       burp -a l -b a
              Lists all the files in all the backups.

       burp -a l -b 1 -r myregex
              Lists all the files in backup number 1 that match the regular expression 'myregex'.

       burp -a L -b 1 -r myregex
              Long  lists  all  the  files  in  backup number 1 that match the regular expression
              'myregex'. This is like doing an 'ls -l'.

       burp -a r -b 1 -r myregex
              Restores all the files in  backup  number  1  that  match  the  regular  expression
              'myregex' back to their original location.

       burp -a r -b 1 -r myregex -d /tmp/restoredir
              Restores  all  the  files  in  backup  number  1  that match the regular expression
              'myregex' into the directory /tmp/restoredir.

       burp -a r -b 1 -r myregex -d /tmp/restoredir -s 2
              Restores all the files in  backup  number  1  that  match  the  regular  expression
              'myregex' into the directory /tmp/restoredir and strip 2 leading path components.

       burp -a r
              Restores all the files in the most recent backup to their original location.

       burp -a v
              Verifies the most recent backup.

       burp -a v -b 1 -r myregex
              Verifies  everything  in  backup  number  1  that  matches  the  regular expression
              'myregex'.

       burp -a D -b 1
              Deletes backup number 1. Note that burp will not  delete  backup  directories  that
              other backup directories depend upon.

       burp -a t
              Timed  backup.  The  same as 'burp -a b', except that a script is run on the server
              before deciding to go ahead. The intention is that this command will be  run  on  a
              repeating  cron  job with a short interval, and that the server will decide when it
              is time for a new backup.

       burp -a L -b 1 -d ''
              Long list the top level directory of backup 1.

       burp -a L -b 1 -d '/home/graham'
              Long list the /home/graham directory of backup 1. These '-d' versions of  the  list
              function provide the ability to 'browse' backups.

       burp -C altclient -a L
              Long list the top level directory of backup 1 on client 'altclient'.

       burp -C altclient -a r -b 1 -r myregex -d /tmp/restoredir
              Restores  all  the  files in backup number 1 from client 'altclient' that match the
              regular expression 'myregex' into the directory /tmp/restoredir.

SERVER CONFIGURATION FILE OPTIONS

       . [path]
              Read an additional configuration file.

       mode=server
              Required to run in server mode.

       port=[port number]
              Defines the main TCP port that the server listens on.

       status_port=[port number]
              Defines the TCP port that the server listens on for status requests.

       daemon=[0|1]
              Whether to daemonise. The default is 1.

       fork=[0|1]
              Whether to fork children. The default is 1.

       directory=[path]
              Path to the directory in which to store backups.

       directory_tree=[0|1]
              When turned on (which is the default)  and  the  client  is  on  version  1.3.6  or
              greater,  the  structure  of  the storage directory will mimic that of the original
              filesystem on the client.

       timestamp_format=[strftime format]
              This allows you to tweak the format of the timestamps of  individual  backups.  See
              'man  strftime'  to see available substitutions. If this option is unset, burp uses
              "%Y-%m-%d %H:%M:%S".

       password_check=[0|1]
              Allows you to turn client password checking on or  off.  The  default  is  on.  SSL
              certificates  will  still  be checked if you turn passwords off. This option can be
              overridden by the client configuration files in clientconfdir on the server.

       clientconfdir=[path]
              Path to the directory that contains client configuration files.

       lockfile=[path]
              Path  to  the  lockfile  that  ensures  that  two  server  processes   cannot   run
              simultaneously.

       pidfile=[path]
              Synonym for lockfile.

       syslog=[0|1]
              Log to syslog. Defaults to off.

       stdout=[0|1]
              Log to stdout. Defaults to on.

       keep=[number]
              Number of backups to keep. This can be overridden by the client configuration files
              in clientconfdir on the server. Specify multiple 'keep' entries on  separate  lines
              in  order  to  keep multiple periods of backups. For example, assuming that you are
              doing a backup a day, keep=7 keep=4 keep=6 (on separate lines) will  keep  7  daily
              backups,  4  weekly  backups  (7x4=28),  and  6  multiples of 4 weeks (7x4x6=168) -
              roughly 6 monthly backups. Effectively, you  will  be  guaranteed  to  be  able  to
              restore  up  to  168  days  ago, with the number of available backups exponentially
              decreasing as you go back in time to that point. In this example, every 7th  backup
              will  be  hardlinked  to  allow  burp  to  safely  delete intermediate backups when
              necessary. You can have as many 'keep' lines as you like, as  long  as  they  don't
              exceed  52560000  when  multiplied together. That is, a backup every minute for 100
              years.

       hardlinked_archive=[0|1]
              On the server, defines whether to keep hardlinked files in the backups, or  whether
              to  generate  reverse  deltas and delete the original files. Can be set to either 0
              (off) or 1 (on). Disadvantage: More disk space will  be  used  Advantage:  Restores
              will  be  faster,  and  since  no reverse deltas need to be generated, the time and
              effort the server needs at the end of a backup is reduced.

       max_hardlinks=[number]
              On the server, the number of times that a single file can be hardlinked. The  bedup
              program also obeys this setting. The default is 10000.

       librsync=[0|1]
              When  set  to  0,  delta  differencing  will  not  take place. That is, when a file
              changes, the server will request the whole new file. The default is 1. This  option
              can be overridden by the client configuration files in clientconfdir on the server.

       compression=gzip[0-9]
              Choose  the  level  of  gzip  compression for files stored in backups. Setting 0 or
              gzip0 turns compression off. The default is gzip9. This option can be overridden by
              the client configuration files in clientconfdir on the server.

       version_warn=[0|1]
              When  this  is  on,  which is the default, a warning will be issued when the client
              version does not match the server version. This option can  be  overridden  by  the
              client configuration files in clientconfdir on the server.

       client_lockdir=[path]
              Path  to  the directory in which to keep per-client lock files. By default, this is
              set to the path given by the 'directory' option.

       user=[username]
              Run as a particular user. This can be overridden by the client configuration  files
              in clientconfdir on the server.

       group=[groupname]
              Run as a particular group. This can be overridden by the client configuration files
              in clientconfdir on the server.

       umask=[umask]
              Set the file creation umask. Default is 0022.

       ratelimit=[Mb/s]
              Set the network send rate limit, in Mb/s. If this option is not  given,  burp  will
              send data as fast as it can.

       network_timeout=[s]
              Set the network timeout in seconds. If no data is sent or received over a period of
              this length, burp will give up. The default is 7200 seconds (2 hours).

       working_dir_recovery_method=[resume|use|delete]
              This option tells the server what to do when it finds the working directory  of  an
              interrupted  backup (perhaps somebody pulled the plug on the server, or something).
              This can be overridden by the client configurations files in clientconfdir  on  the
              server. Options are...

       delete: Just delete the old working directory.

       use: Convert the working directory into a complete backup.

       resume:  Simply  continue the previous backup from the point at which it left off, at file
       granularity. NOTE: If the client has changed its include/exclude configuration  since  the
       backup was interrupted, the recovery method will automatically switch to 'use'.

       resume_partial=[0|1]
              Turn     this     on     to     enable     'resume    partial'    code.    Requires
              'working_dir_recovery_method=resume'. When resuming an interrupted  transfer  of  a
              single file, it attempts to use previously transferred blocks of that file in order
              to be more efficient. However, situations have been reported where the file on  the
              server  side just gets bigger forever, so this feature now defaults to being turned
              off.

       client_can_delete=[0|1]
              Turn this off to prevent clients from deleting backups with the '-a D' option.  The
              default is that clients can delete backups.

       client_can_force_backup=[0|1]
              Turn this off to prevent clients from forcing backups with the '-a b' option. Timed
              backups will still work. The default is that clients can force backups.

       client_can_list=[0|1]
              Turn this off to prevent clients from listing backups with the '-a l'  option.  The
              default is that clients can list backups.

       client_can_restore=[0|1]
              Turn  this  off to prevent clients from initiating restores with the '-a r' option.
              The default is that clients can initiate restores.

       client_can_verify=[0|1]
              Turn this off to prevent clients from initiating a  verify  job  with  the  '-a  v'
              option. The default is that clients can initiate a verify job.

       restore_client=[client]
              A client that is permitted to list and restore files belonging to any other client.
              You may specify multiple restore_clients. If this is too permissive, you may set  a
              restore_client  for  individual  original  clients  in the individual clientconfdir
              files. Note that restoring a backup from a Windows computer onto a  Linux  computer
              will  currently  leave the VSS headers in place at the beginning of each file. This
              will be addressed in a future version of burp.

       ssl_cert_ca=[path]
              The path to the SSL CA certificate. This file will probably be the same on both the
              server  and the client. The file should contain just the certificate in PEM format.
              For  more  information  on  this,  and  the  other  ssl_*   options,   please   see
              docs/burp_ca.txt.

       ssl_cert=[path]
              The  path to the server SSL certificate. It works for me when the file contains the
              concatenation of the certificate and private key in PEM format.

       ssl_key=[path]
              The path to the server SSL private key in PEM format.

       ssl_key_password=[password]
              The SSL key password.

       ssl_cert_password=[password]
              Synonym for ssl_key_password.

       ssl_ciphers=[cipher list]
              Allowed SSL ciphers. See openssl ciphers for details.

       ssl_dhfile=[path]
              Path to Diffie-Hellman parameter file. To generate one with openssl, use a  command
              like this: openssl dhparam -out dhfile.pem -5 1024

       max_children=[number]
              Defines  the  number  of  child  processes  to fork (the number of clients that can
              simultaneously connect. The default is 5.

       max_status_children=[number]
              Defines the number of status child processes to fork (the number of status  clients
              that can simultaneously connect. The default is 5.

       max_storage_subdirs=[number]
              Defines  the number of subdirectories in the data storage areas. The maximum number
              of subdirectories that ext3 allows is 32000. If you do  not  set  this  option,  it
              defaults to 30000.

       timer_script=[path]
              Path  to  the script to run when a client connects with the timed backup option. If
              the script exits with code 0, a backup will run. The first two  arguments  are  the
              client  name  and  the  path  to  the  'current'  storage directory. The next three
              arguments are reserved, and user arguments are  appended  after  that.  An  example
              timer  script  is provided. The timer_script option can be overridden by the client
              configuration files in clientconfdir on the server.

       timer_arg=[string]
              A user-definable argument to the timer script. You can  have  many  of  these.  The
              timer_arg   options  can  be  overridden  by  the  client  configuration  files  in
              clientconfdir on the server.

       notify_success_script=[path]
              Path to the script to run when a backup succeeds. User arguments are appended after
              the  first  five  reserved  arguments.  An  example  notify script is provided. The
              notify_success_script option can be overriddden by the client  configuration  files
              in clientconfdir on the server.

       notify_success_arg=[string]
              A user-definable argument to the notify success script. You can have many of these.
              The notify_success_arg options can be overriddden by the client configuration files
              in clientconfdir on the server.

       notify_success_warnings_only=[0|1]
              Set  to  1  to  send  success  notifications  when there were warnings. If this and
              notify_success_changes_only are not turned on,  success  notifications  are  always
              sent.

       notify_success_changes_only=[0|1]
              Set  to  1  to  send success notifications when there were new or changed files. If
              this and notify_success_warnings_only are not turned on, success notifications  are
              always sent.

       notify_failure_script=[path]
              The same as notify_success_script, but for backups that failed.

       notify_failure_arg=[string]
              The same as notify_failure_arg, but for backups that failed.

       dedup_group=[string]
              Enables you to group clients together for file deduplication purposes. For example,
              you might want to set 'dedup_group=xp' for each Windows XP client, and then run the
              bedup program on a cron job every other day with the option '-g xp'.

       server_script_pre=[path]
              Path  to  a  script  to  run  on  the  server after each successfully authenticated
              connection but before any work is carried out.  The  arguments  to  it  are  'pre',
              '(client  command)',  'reserved3'  to  'reserved5',  and  then arguments defined by
              server_script_pre_arg. If the script returns non-zero, the task asked  for  by  the
              client  will not be run. This command and related options can be overriddden by the
              client configuration files in clientconfdir on the server.

       server_script_pre_arg=[string]
              A user-definable argument to the server pre script. You can have many of these.

       server_script_pre_notify=[0|1]
              Turn on to send a notification email when the server pre script  returns  non-zero.
              The  output  of  the script will be included in the email. The default is off. Most
              people will not want this turned on because clients usually contact the  server  at
              20  minute intervals and this could cause a lot of emails to be generated. Requires
              the notify_failure options to be set.

       server_script_post=[path]
              Path to a script to run on the server before the client disconnects. The  arguments
              to  it  are  'post',  '(client  command)',  'reserved3'  to  'reserved5',  and then
              arguments defined by server_script_post_arg. This command and related  options  can
              be overriddden by the client configuration files in clientconfdir on the server.

       server_script_post_arg=[string]
              A user-definable argument to the server post script. You can have many of these.

       server_script_post_notify=[0|1]
              Turn  on to send a notification email when the server post script returns non-zero.
              The output of the script will be  included  in  the  email.  The  default  is  off.
              Requires the notify_failure options to be set.

       server_script=[path]
              You  can  use  this to save space in your config file when you want to run the same
              server script twice. It overrides server_script_pre  and  server_script_post.  This
              command and related options can be overriddden by the client configuration files in
              clientconfdir on the server.

       server_script_arg=[path]
              Goes    with    server_script    and    overrides     server_script_pre_arg     and
              server_script_post_arg.

       server_script_notify=[0|1]
              Turn  on  to send a notification emails when the server pre and post scripts return
              non-zero. The output of the script will be included it the email.  The  default  is
              off. Requires the notify_failure options to be set.

       server_script_post_run_on_fail=[0|1]
              If this is set to 1, server_script_post will always be run. The default is 0, which
              means that if the task asked for by the client fails, server_script_post  will  not
              be run.

       autoupgrade_dir=[path]
              Path to autoupgrade directory from which upgrades are downloaded. The option can be
              left unset in order not to autoupgrade clients. Please see docs/autoupgrade.txt  in
              the source package for more help with this option.

       ca_conf=[path]
              Path  to  certificate  authority configuration file. The CA configuration file will
              usually be /etc/burp/CA.cnf. The CA directory indicated by CA.cnf will  usually  be
              /etc/burp/CA.  If  ca_conf  is  set and the CA directory does not exist, the server
              will create, populate it, and the paths indicated by ssl_cert_ca, ssl_cert, ssl_key
              and  ssl_dhfile  will be overwritten. For more detailed information on this and the
              other ca_* options, please see docs/burp_ca.txt.

       ca_name=[name]
              Name of the CA that the server will generate when using the ca_conf option.

       ca_server_name=[name]
              The name that the server will put into its  own  SSL  certficates  when  using  the
              ca_conf option.

       ca_burp_ca=[path]
              Path to the burp_ca script when using the ca_conf option.

CLIENT CONFIGURATION FILE OPTIONS

       . [path]
              Read an additional configuration file.

       mode=client
              Required to run in client mode.

       server=[IP address or hostname]
              Defines the server to connect to.

       port=[port number]
              Defines the TCP port that the server is listening on.

       cname=[password]
              Defines the client name to identify as to the server.

       password=[password]
              Defines the password to send to the server.

       lockfile=[path]
              Path   to   the  lockfile  that  ensures  that  two  client  processes  cannot  run
              simultaneously (this currently doesn't work on Windows).

       pidfile=[path]
              Synonym for lockfile.

       syslog=[0|1]
              Log to syslog. Defaults to off.

       stdout=[0|1]
              Log to stdout. Defaults to on.

       progress_counter=[0|1]
              Print progress counters on stdout. Defaults to on.

       user=[username]
              Run as a particular user (not supported on Windows).

       group=[groupname]
              Run as a particular group (not supported on Windows).

       ratelimit=[Mb/s]
              Set the network send rate limit, in Mb/s. If this option is not  given,  burp  will
              send data as fast as it can.

       network_timeout=[s]
              Set the network timeout in seconds. If no data is sent or received over a period of
              this length, burp will give up. The default is 7200 seconds (2 hours).

       ca_burp_ca=[path]
              Path to the burp_ca script (burp_ca.bat on Windows). For more information on  this,
              please see docs/burp_ca.txt.

       ca_csr_dir=[path]
              Directory where certificate signing requests are generated. For more information on
              this, please see docs/burp_ca.txt.

       ssl_cert_ca=[path]
              The path to the SSL CA certificate. This file will probably be the same on both the
              server  and the client. The file should contain just the certificate in PEM format.
              For  more  information  on  this  and  the  other   ssl_*   options,   please   see
              docs/burp_ca.txt.

       ssl_cert=[path]
              The  path to the client SSL certificate. It works for me when the file contains the
              concatenation of the certificate and private key in PEM format.

       ssl_key=[path]
              The path to the client SSL private key in PEM format.

       ssl_key_password=[password]
              The SSL key password.

       ssl_cert_password=[password]
              Synonym for ssl_key_password.

       ssl_peer_cn=[string]
              Must match the common name in the SSL certificate that the  server  gives  when  it
              connects. If ssl_peer_cn is not set, the server name will be used instead.

       ssl_ciphers=[cipher list]
              Allowed SSL ciphers. See openssl ciphers for details.

       server_can_restore=[0|1]
              To prevent the server from initiating restores, set this to 0. The default is 1.

       encryption_password=[password]
              Set  this  to  enable  client  side  file  Blowfish  encryption. If you do not want
              encryption, leave this field out of your config file. IMPORTANT:  Configuring  this
              renders delta differencing pointless, since the smallest real change to a file will
              make the whole file look different. Therefore, activating  this  option  turns  off
              delta  differencing so that whenever a client file changes, the whole new file will
              be uploaded on the next  backup.  ALSO  IMPORTANT:  If  you  manage  to  lose  your
              encryption  password,  you  will  not  be  able to unencrypt your files. You should
              therefore think about having a copy of the encryption password  somewhere  off-box,
              in  case  of  your client hard disk failing. FINALLY: If you change your encryption
              password, you will end up with a mixture of files  on  the  server  with  different
              encryption  and  it  may become tricky to restore more than one file at a time. For
              this reason, if you change your encryption password, you may want to start a  fresh
              chain  of  backups  (by moving the original set aside, for example). Burp will cope
              fine with turning the same encryption password on and off between backups, and will
              restore a backup of mixed encrypted and unencrypted files without a problem.

       backup_script_pre=[path]
              Path to a script to run before a backup. The arguments to it are 'pre', 'reserved2'
              to 'reserved5', and then arguments defined by backup_script_pre_arg.

       backup_script_pre_arg=[string]
              A user-definable argument to the backup pre script. You can have many of these.

       backup_script_post=[path]
              Path to a script to run after a backup. The arguments to it are  'post',  [0|1]  if
              the  backup  failed  or  succeeded,  'reserved3' to 'reserved5', and then arguments
              defined by backup_script_post_arg.

       backup_script_post_arg=[string]
              A user-definable argument to the backup post script. You can have many of these.

       backup_script_post_run_on_fail=[0|1]
              If this is set to 1, backup_script_post will be run whether the backup succeeds  or
              not.  The default is 0, which means that backup_script_post will only be run if the
              backup succeeds.

       restore_script_pre=[path]
              Path to a script  to  run  before  a  restore.  The  arguments  to  it  are  'pre',
              'reserved2' to 'reserved5', and then arguments defined by restore_script_pre_arg.

       restore_script_pre_arg=[string]
              A user-definable argument to the restore pre script. You can have many of these.

       restore_script_post=[path]
              Path  to  a script to run after a restore. The arguments to it are 'post', [0|1] if
              the restore failed or succeeded, 'reserved3' to  'reserved5',  and  then  arguments
              defined by restore_script_post_arg.

       restore_script_post_arg=[string]
              A user-definable argument to the restore post script. You can have many of these.

       restore_script_post_run_on_fail=[0|1]
              If  this  is set to 1, restore_script_post will be run whether the restore succeeds
              or not. The default is 0, which means that restore_script_post will only be run  if
              the restore succeeds.

       backup_script=[path]
              You  can  use  this to save space in your config file when you want to run the same
              script  before  and  after   a   backup.   It   overrides   backup_script_pre   and
              backup_script_post.

       backup_script_arg=[path]
              Goes     with     backup_script    and    overrides    backup_script_pre_arg    and
              backup_script_post_arg.

       restore_script=[path]
              You can use this to save space in your config file when you want to  run  the  same
              script   before   and   after   a  restore.  It  overrides  restore_script_pre  and
              restore_script_post.

       restore_script_arg=[path]
              Goes    with    restore_script    and    overrides    restore_script_pre_arg    and
              restore_script_post_arg.

       autoupgrade_dir=[path]
              Path  to  autoupgrade  directory  into  which  upgrades  are downloaded. Please see
              docs/autoupgrade.txt in the source package for more help with this option.  If  you
              do not want your client to autoupgrade, do not set this option.

       autoupgrade_os=[string]
              Name  of the client operating system. Should match a directory name in the server's
              autoupgrade_dir. If you do not want your client to autoupgrade,  do  not  set  this
              option.

INCLUDES / EXCLUDES

       The  following  options  specify  exactly  what is backed up. The client can specify these
       options, or if you include at least one 'include=' in the client  configuration  files  on
       the server, the server will override them all.

       include=[path]
              Path  to  include  in  the backup. You can have multiple include lines. Use forward
              slashes '/', not backslashes '\' as path delimiters.

       exclude=[path]
              Path to exclude from the backup. You can have multiple exclude lines.  Use  forward
              slashes '/', not backslashes '\' as path delimiters.

       include_regex=[regular expression]
              Not implemented.

       exclude_regex=[regular expression]
              Exclude paths that match the regular expression.

       include_ext=[extension]
              Extensions  to  include  in  the  backup.  Case  insensitive.  Nothing else will be
              included in the backup. You can have multiple include extension lines. For example,
              set  'txt'  to  include  files that end in '.txt'. You need to specify an 'include'
              line so that burp knows where to start looking.

       exclude_ext=[extension]
              Extensions to exclude from the backup. Case  insensitive.  You  can  have  multiple
              exclude extension lines. For example, set 'vdi' to exclude VirtualBox disk images.

       exclude_comp=[extension]
              Extensions  to  exclude  from  compression. Case insensitive. You can have multiple
              exclude compression lines. For example, set 'gz'  to  exclude  gzipped  files  from
              compression.

       exclude_fs=[fstype]
              File  systems  to  exclude from the backup. Case insensitive. You can have multiple
              exclude file system lines. For example, set 'tmpfs' to exclude tmpfs. Burp  has  an
              internal  mapping  of  file  system  names to file system IDs. If you know the file
              system ID, you can use that instead. For example, 'exclude_fs  =  0x01021994'  will
              also exclude tmpfs.

       min_file_size=[b/Kb/Mb/Gb]
              Do not back up files that are less than the specified size. Example: 'min_file_size
              = 10Mb'. Set to 0 (the default) to have no limit.

       max_file_size=[b/Kb/Mb/Gb]
              Do  not  back  up  files  that  are  greater  than  the  specified  size.  Example:
              'max_file_size = 10Mb'. Set to 0 (the default) to have no limit.

       cross_filesystem=[path]
              Allow backups to cross a particular filesystem mountpoint.

       cross_all_filesystems=[0|1]
              Allow backups to cross all filesystem mountpoints.

       nobackup=[file name]
              If  this  file  system entry exists, the directory containing it will not be backed
              up.

       read_fifo=[path]
              Do not back up the given fifo itself, but open it  for  reading  and  back  up  the
              contents as if it were a regular file.

       read_all_fifos=[0|1]
              Open all fifos for reading and back up the contents as if they were regular files.

       read_blockdev=[path]
              Do  not  back up the given block device itself, but open it for reading and back up
              the contents as if it were a regular file.

       read_all_blockdevs=[0|1]
              Open all block devices for reading and back up the contents as if they were regular
              files.

       split_vss=[0|1]
              When  backing  up  Windows computers, this option allows you to save the VSS header
              data separate from the file data. The default is off,  which  means  that  the  VSS
              header data is saved prepended to the file data.

       strip_vss=[0|1]
              When backing up Windows computers, this option allows you to prevent the VSS header
              data being backed up. The default is off. To restore  a  backup  that  has  no  VSS
              information on Windows, you need to give the client the '-x' command line option.

       vss_drives=[list of drive letters]
              When  backing  up Windows computers, this option allows you to specify which drives
              have VSS snapshots taken of them. If you omit this option, burp will  automatically
              decide  based  on  the  'include'  options. If you want no drives to have snapshots
              taken of them, you can specify '0'.

SERVER CLIENTCONFDIR FILE

       For the server to know about clients that can contact it, you need to place a  file  named
       after  the  client  in  clientconfdir.  Files  beginning  with  '.' or ending with '~' are
       ignored. Directories are also ignored.

       The file name must match the name in the 'cname' field on the client.

       ssl_peer_cn=[string] must match the common name in the SSL  certificate  that  the  client
       gives  when  it  connects. If ssl_peer_cn is not set, the client name will be used instead
       (the clientconfdir file name).

       The file needs to contain a line like password=[password] that matches the same  field  on
       the  client,  or passwd=[encrypted password] - where the plain text password on the client
       will be tested against an encrypted password of the kind you might find in /etc/passwd.

       Additionally, the following options can be overridden here for each client:
              directory      directory_tree      timestamp_format       password_check       keep
              working_dir_recovery_method    resume_partial    librsync    version_warn    syslog
              client_can_delete   client_can_force_backup   client_can_list    client_can_restore
              client_can_verify     restore_client     compression     timer_script     timer_arg
              notify_success_script        notify_success_arg        notify_success_warnings_only
              notify_failure_script      notify_failure_arg     dedup_group     server_script_pre
              server_script_pre_arg          server_script_pre_notify          server_script_post
              server_script_post_arg  server_script_post_notify  server_script  server_script_arg
              server_script_notify server_script_post_run_on_fail

       Additionally, the includes and excludes can  be  overridden  here,  as  described  in  the
       section above.

       As  with  the  other  configuration files, extra configuration can be included with the '.
       path/to/config/file' syntax.

Some notes on SSL certificates

       The burp example configs come with example SSL certificates and keys. You  can  use  these
       and  burp  will  work.  But if you are worried about network security, you should generate
       your own certificates and keys and point your config files to them. To create the  example
       files,  I used a handy interface to openssl, called 'tinyca' (http://tinyca.sm-zone.net/).
       If you are using Debian, you can run 'apt-get install tinyca' to get it. There is also the
       option  of  using  burp_ca,  which  you  can  find in the source distribution, courtesy of
       Patrick Koppen.

Examining backups

       As well as using the client list options described above,  you  can  go  directly  to  the
       storage directory on the server. The backups for a client are in the directory named after
       the client. Inside each backup directory is a file called manifest.gz.

       This contains a list of all the files in the backup, and where they originally  came  from
       on the client.

       There is also a 'log.gz' file in the backup directory, which contains the output generated
       by the server during the backup.

       The 'data' directory contains complete backup files.

       The 'deltas.reverse' directory contains reverse deltas that can be  applied  to  the  data
       from the next backup in the sequence (indicated by the contents of the 'forward' file).

       Anything with a .gz suffix is compressed in gzip format.  You can use standard tools, such
       as zcat, zless or cp, to view them or copy them elsewhere.

Server initiated backups

       You can queue a backup on the server, to be performed when the client next makes  contact.
       To  do  this,  you  put  a  file  called 'backup' into the top level of the client storage
       directory. The contents of the file are ignored.

Server initiated restores

       You can queue a restore on the server, to be performed when the client next makes contact.
       To  do  this,  you  put  a  file called 'restore' into the top level of the client storage
       directory. The client can deny server initiated restores by setting "server_can_restore=0"
       in its burp.conf. Valid fields to include in the restore file are:

       orig_client=[client]
              The  original  client to restore from. Equivalent to '-C' when initiating a restore
              from a client. Do not include this line when restoring to the original client.  See
              also the 'restore_client' server option.

       backup=[number|a]
              The  number  of  the  backup  to restore from. Equivalent to '-b' when initiating a
              restore from the client.

       overwrite=[0|1]
              Whether to overwrite existing files. Equivalent to '-f' when initiating  a  restore
              from the client.

       strip=[number]
              Number  of  leading  path components to strip. Equivalent to '-s' when initiating a
              restore from the client.

       restoreprefix=[path]
              Prefix to the restore path. Equivalent to '-d' when initiating a restore  from  the
              client.

       regex=[regular expression]
              Only  restore  files  matching  the  regular  expression.  Equivalent  to '-r' when
              initiating a restore from the client.

       include=[path]
              Restore directories and files that match the  path.  If  it  is  a  directory,  the
              contents  of the directory will be restored. You can have multiple 'include' lines.
              There is no equivalent when initiating a restore from the client.

       As a minimum, the 'restore' file needs to contain a 'backup' option, and  one  'regex'  or
       'include' line.

SIGNALS

       Sending  signal  1  (HUP) to the main server process will cause it to reload. For the vast
       majority of configuration changes, a reload is unnecessary as  the  server  will  pick  up
       changes "on-the-fly". Sending signal 12 (USR2) to the main server process will cause it to
       wait until there are no longer any child processes, and then exit.  The  intention  is  to
       help with upgrades without interrupting current backups. if you are running upstart, a new
       burp server process will start up when the old one exits.

BUGS

       If  you  find  bugs,  please  report  them  to   the   email   list.   See   the   website
       <http://burp.grke.net/> for details.

AUTHOR

       The main author of Burp is Graham Keeling.

COPYRIGHT

       See the LICENCE file included with the source distribution.

                                               Burp                                       Burp(8)