
#include "bacula_template.inc" title="Installing Bacula" num=4

<h1>Installing Bacula</h1>
<h2>General</h2>
In general, you will need the <b>Bacula</b> source release, and if you
want to run a Windows client, you will need the <b>Bacula</b> Windows
binary release. However, <b>Bacula</b> needs certain third party 
packages (such as <b>readline</b>, 
<b>SQLite</b>, <b>MySQL</b> to build properly depending on
the options you specify. To simplify your task, we have combined
a number of these packages into two <b>depkgs</b> releases (Dependency
Packages). This can vastly simplify your life by providing you with
all the necessary packages rather than requiring you to find them
on the Web, load them, and install them.

<h2><a name="Dependency">Dependency Packages</a></h2>
As discussed above, we have combined a number of third party
packages that <b>Bacula</b> might need into the <b>depkgs</b>
and <b>depkgs1</b> releases. 
Typically, they will be named <b>depkgs-ddMMMyy.tar.gz</b>
and <b>depkgs1-ddMMyy.tar.gz</b>
where <b>dd</b> is the day we release it, <b>MMM</b> is the abbreviated
month (e.g. Jan), and <b>yy</b> is the year. 
An actual example is:
<b>depkgs-07Apr02.tar.gz</b>. To install and build
this package (if needed), you do the following:
<ol>
  <li>Create a <b>bacula</b> directory, into which you will place
      both the <b>Bacula</b> source as well as the dependency package.</li>
  <li>Detar the <b>depkg</b> into the <b>bacula</b> directory.</li>
  <li>cd bacula/depkgs</li>
  <li>make</li>
</ol>
Although the exact composition of the dependency packages may
change from time to time, the current makeup is the following:
<p>
<table cellspacing="4" cellpadding="4" border="5">
<tr> <th>3rd Party Package</th> <th>depkgs</th> <th>depkgs1</th></tr>
<tr> <td>SQLite</td> <td align="center">X</td> <td align="center">-</td>
<tr> <td>mtx</td> <td align="center">X</td> <td align="center">-</td>
<tr> <td>readline</td> <td align="center">-</td> <td align="center">X</td>
</table>
<p>

Note, some of these packages are quite large, so that this part
can be a bit time consuming. The above instructions will build all the packages 
contained in the directory. However, when building <b>Bacula</b>,
it will take only those pieces that it actually needs.
<p>
Alternatively, you can make just the packages that are needed.
For example,
<pre>
cd bacula/depkgs
make sqlite
</pre>
will configure and build only the SQLite package.
<p>
You should build the packages that you will require in <b>depkgs</b> 
and/or <b>depkgs1</b> prior to configuring and building <b>Bacula</b>,
since <b>Bacula</b> will need them during the build process.
<p>
Even if you do not use SQLite, you might find it worth while to 
build <b>mtx</b> because the <b>tapeinfo</b> program that comes
with it can often provide you with valuable information about
your SCSI tape drive (e.g. compression, min/max block sizes, ...).

<h2><a name="Systems">Operating Systems Supported</a></h2>
Bacula is supported on the following operating systems:
<pre>
 - Linux (RedHat, Gentoo)
 - Solaris
 - Win98, WinNT, WinXP, WinMe, Win2K (Client only)
 - FreeBSD
</pre>
In addition, Bacula is known to build and run on the following
systems.
<pre>
 - OpenBSD
 - Irix
 - Darwin
 - AIX
</pre>

<h2><a name="Building">Building Bacula from Source</a></h2>
<P>The basic installation is rather simple. 
</P>
<OL>
   <li>Install and build any <b>depkgs</b> as noted above.</li>
   <li>Configure and install MySQL (if desired).  <a
       href="mysql.html">Installing and Configuring MySQL Phase I</a>.
       This is necessary so that the MySQL header files are available
       while compiling <b>Bacula</b>.
       <br>Note, if you already have a running MySQL on your system, you
       can skip this phase.</li>
   <li>As an alternative to MySQL, configure and install SQLite,
       which is part of the <b>depkgs</b>.
       <a href="sqlite.html">Installing and Configuring SQLite</a>.</li>
   <li>Detar the <b>Bacula</b> source code preferably into the <b>bacula</b>
       directory discussed above.</li>
   <li><B>cd</B> to the directory containing the source code.</li>
   <li>./configure (with appropriate options as described below)</li>
   <li>Check the output of ./configure very carefully, especially
       the Install binaries and Install config files directories.
       If they are not correct, please rerun ./configure until they
       are. The output from ./configure is stored in <b>config.out</b>
       and can be re-displayed at any time without rerunning the 
       ./configure by doing <b>cat config.out</b>.</li>
   <li>make
       <p>If you get errors while linking in the Storage daemon
        directory (src/stored), it is probably because you have not
        loaded the static libraries on your system.  I noticed this
        problem on a Solaris system.  To correct it, make sure that you
        have not added <b>enable-static-tools</b> to the
        <b>./configure</b> command.  </li>
   <li>make install</li>
   <li>Create valid configuration files for each of the three daemons
       (Directory, File, Storage) and for the Console program.  For the
       details of how to do this, please see <a
       href="configure.html">Setting Up Bacula Configuration
       Files</a> in the Configuration chapter of this manual.  
       We recommend that you start by modifying the default configuration
       files supplied. Please take care when modifying passwords, which
       were randomly generated, and the daemon <b>Name</b>s as the
       passwords and names must agree between the configuration files
       for security reasons. </li>
   <li>Create the Bacula MySQL databases and tables (if using MySQL)
       <a href="mysql.html#mysql_phase2">Installing and 
       Configuring MySQL Phase II</a> or alternatively
       if you are using SQLite 
       <a href="sqlite.html#phase2">Installing and Configuring
       SQLite Phase II</a>.
   <li>Start Bacula (<b>./bacula start</b>)</li>
   <li>Interface with Bacula using the Console program</li>
</OL>

<p>If all goes well, the <B>./configure</B> will correctly determine
which operating system you are running and configure the source code
appropriately. Currently, FreeBSD, Linux (RedHat), and Solaris are
supported.
<p>If you install <b>Bacula</b> on more than one system, and they
are identical, you can simply transfer the source tree to that other
system and do a &quot;make install&quot;.  However, if there are differences
in the libraries or OS versions, or you wish to install on a different
OS, you should start from the original compress tar file. If you
do transfer the source tree, and you have previously done a 
./configure command, you MUST do:
<pre>
make distclean
</pre>
prior to doing your new ./configure. This is because the GNU autoconf
tools cache the configuration, and if you re-use a configuration for
a Linux machine on a Solaris, you can be sure your build will fail.
To avoid this, as mentioned above, either start from the tar file,
or do a &quot;make distclean&quot;.
<p>In general, you will probably want to supply a more complicated
<b>configure</b> statement to ensure that the modules you want are
built and that everything is placed into the correct directories. 
<p> For example, on RedHat, one could use the following:
<pre>
CFLAGS="-g -Wall" \\
  ./configure \\
    --sbindir=$HOME/bacula/bin \\
    --sysconfdir=$HOME/bacula/bin \\
    --with-pid-dir=$HOME/bacula/bin/working \\
    --with-subsys-dir=$HOME/bacula/bin/working \\
    --with-mysql=$HOME/mysql \\
    --with-working-dir=$HOME/bacula/bin/working \\
    --with-dump-email=$USER
</pre>


<p>For the developer's convenience, I have added a <b>defaultconfig</b>
script to the <b>examples</b> directory.  This script
script contains the statements that you would normally use, and each
developer/user may modify them to suit his needs. You should
find additional useful examples in this directory as well.

<h2><a name="DB">What Database to Use?</a></h2>
Before building <b>Bacula</b> you need to decide if you
want to use SQLite or MySQL.
If you are not already running MySQL, we recommend that you 
start by using SQLite. This will greatly simplify
the setup for you. 
<p>If you wish to use MySQL as the Bacula catalog, please see the 
<a href="mysql.html">Installing and Configuring MySQL</a> chapter of this
manual. You will need to install MySQL prior to continuing with
the configuration of Bacula.

<p></p>If you wish to use SQLite as the Bacula catalog, please
see <a href="sqlite.html">Installing and Configuring SQLite</a> chapter
of this manual. 

<H2><a name="Options">Configure Options</a></H2>
<P>The following command line options are available for <b>configure</b> to customize your
installation. 
</P>
<DL>
   <dt>--sysbindir=&lt;binary-path&gt;</dt><dd>Defines where the Bacula
       binary (executable) files will be placed during a <b>make 
       install</b> command.</dd>
   <dt>--sysconfdir=&lt;config-path&gt;</dt><dd>Defines where the
       Bacula configuration files should be placed during a <b>make
       install</b> command.</dd>
   <DT>--enable-smartalloc </DT><DD> This enables the inclusion of the
       Smartalloc orphaned buffer detection code.  This option is highly
       recommended.  Because we never build without this option, you may
       experience problems if it is not enabled. This configuration 
       parameter is used while building <b>Bacula</b></dd>
   <dt>--enable-gnome </dt><dd>If you have GNOME installed on your
       computer and you want to use the GNOME GUI Console interface
       to <b>Bacula</b>, you must specify this option. Doing so
       will build everything in the <b>src/gnome-console</b> directory.</dd>
   <dt>--enable-static-tools</dt><dd>This option causes the linker
       to link the Storage daemon utility tools (<b>bls</b>, 
       <b>bextract</b>, and <b>bscan</b>) statically. This permits using
       them without having the shared libraries loaded.  If you have
       problems linking in the <b>src/stored</b> directory, make sure
       you have not enabled this option, or explicitly
       disable static linking by adding <b>--disable-static-tools</b>.</dd>
   <dt>--enable-static-fd</dt><dd>This option causes the make process
       to build a <b>static-bacula-fd</b> in addition to the standard
       File daemon. This static version will include statically linked
       libraries and is required for the Bare Metal recovery. This option
       is largely superceded by using <b>make static-bacula-fd</b> from with
       in the <b>src/filed</b> directory. Also, the <b>--enable-client-only</b>
       option described below is useful for just building a client so that
       all the other parts of the program are not compiled.</dd>
   <dt>--enable-static-sd</dt><dd>This option causes the make process
       to build a <b>static-bacula-sd</b> in addition to the standard
       Storage daemon. This static version will include statically linked
       libraries and could be useful during a Bare Metal recovery.</dd>
   <dt>--enable-static-dir</dt><dd>This option causes the make process
       to build a <b>static-bacula-dir</b> in addition to the standard
       Director. This static version will include statically linked
       libraries and could be useful during a Bare Metal recovery.</dd>
   <dt>--enable-static-cons</dt><dd>This option causes the make process
       to build a <b>static-console</b> and a <b>static-gnome-console</b>
       in addition to the standard console.
       This static version will include statically linked
       libraries and could be useful during a Bare Metal recovery.</dd>
   <dt>--enable-client-only</dt><dd>This option causes the make process
       to build only the File daemon and the libraries that it needs.
       None of the other daemons, storage tools, nor the console will
       be build. Likewise a <b>make install</b> will then only install
       the File daemon. To cause all daemons to be built, you will need
       to do a configuration without this option. This option greatly
       facilitates building a Client on a client only machine.</dd>
   <dt>--enable-largefile</dt><dd>This option (default) causes    
       <b>Bacula</b> to be built with 64 bit file address support if it
       is available on your system. This permits <b>Bacula</b> to read and
       write files greater than 2 GBytes in size.  You may disable this
       feature and revert to 32 bit file addresses by using 
       <b>--disable-largefile</b>.</dd>
   <dt>--with-sqlite=&lt;sqlite-path&gt;</dt><dd> This enables use of
       the SQLite database.  The <b>sqlite-path</b> is not normally
       specified as <b>Bacula</b> looks for the necessary components in
       a standard location (<b>depkgs/sqlite</b>).  See <a
       href="mysql.html">Installing and Configuring MySQL</a> chapter of
       this manual for more details.
   <dt>--with-mysql=&lt;mysql-path&gt;</DT><DD STYLE="margin-bottom: 0.2in">
       This enables building of the Catalog services for Bacula. It
       assumes that MySQL is running on your system, and expects
       it to be installed in the <b>mysql-path</b> that you
       specify.  If this option is not present, the build will
       automatically include the internal <b>Bacula</b> database
       code. We recommend that you use this option if possible.
       If you do use this option, please proceed to installing
       MySQL in the <a href="mysql.html">Installing and Configuring
       MySQL</a> chapter before proceeding with the configuration.
    <dt>--with-readline=&lt;readline-path&gt;</dt><dd>Tells Bacula
        where where <b>readline</b> is installed. Normally, Bacula will
        find readline if it is in a standard library. If it is not found
        and no --with-readline is specified, readline will be disabled.
        This option affects the <b>Bacula</b> build.</dd>
    <dt>--with-tcp-wrappers=&lt;path&gt;</dt><dd>This specifies that you
        want TCPWrappers compiled in (untested). The path is optional since
        Bacula will normally find the libraries in the standard locations.
        This option affects the <b>Bacula</b> build. <b>Please note 
        that this option has not been fully tested.</b></dd>
    <dt>--with-working-dir=&lt;working-directory-path&gt;</dt>
        <dd>This option is mandatory and specifies a directory
        into which <b>Bacula</b> may safely place files that
        will remain between <b>Bacula</b> executions. For example,
        if the internal database is used, <b>Bacula</b> will keep
        those files in this directory. 
        This option is only used
        to modify the daemon configuration files. You may also accomplish
        the same thing by directly editing them later. </dd>
    <dt>--with-base-port=&lt;port=number&gt;</dt><dd> In order to run,
        <b>Bacula</b> needs three TCP/IP ports (one for the Bacula
        Console, one for the Storage daemon, and one for the File daemon).
        The <b>--with-baseport</b> option will automatically assign three
        ports beginning at the base port address specified.  You may
        also change the port number in the resulting configuration
        files.  However, you need to take care that the numbers
        correspond correctly in each of the three daemon configuration
        files.  The default base port is 9101, which assigns ports 9101
        through 9103. These ports (9101, 9102, and 9103) have been
        officially assigned to <b>Bacula</b> by IANA.
        This option is only used
        to modify the daemon configuration files. You may also accomplish
        the same thing by directly editing them later. </dd>
    <dt>--with-dump-email=&lt;email-address&gt;</dt><dd>This option specifies
        the email address where any core dumps should be set. This option
        is normally only used by developers.</dd>
    <dt>--with-pid-dir=&lt;PATH&gt;</dt>
        <dd>This specifies where Bacula should place the process id
            file during execution. The default is: <b>/var/run</b>.</dd>
    <dt>--with-subsys-dir=&lt;PATH&gt;</dt>
        <dd>This specifies where Bacula should place the subsystem lock
            file during execution. The default is <b>/var/run/subsys</b>.
            Please make sure that you do not specify the same directory
            for this directory and for the <b>sbindir</b> directory. </dd>
    <dt>--with-dir-password=&lt;Password&gt;</dt>
        <dd>This option allows you to specify the password used to 
            access the Directory (normally from the Console program).
            If it is not specified, configure will automatically create a random
            password.</dd>
    <dt>--with-fd-password=&lt;Password&gt;</dt>
        <dd>This option allows you to specify the password used to 
            access the File daemon (normally called from the Director).
            If it is not specified, configure will automatically create a random
            password.</dd>
    <dt>--with-sd-password=&lt;Password&gt;</dt>
        <dd>This option allows you to specify the password used to 
            access the Directory (normally called from the Director).
            If it is not specified, configure will automatically create a random
            password.</dd>
</DL>


Note, many other options are presented when you do a <b>./configure
--help</b>, but they are not implemented.

<H2>Recommended Options for most Systems</H2>
<P>For most systems, we recommend starting with the following options: 
</P>
<pre>
./configure \\
  --enable-smartalloc \\
  --sbindir=$HOME/bacula/bin \\
  --sysconfdir=$HOME/bacula/bin \\
  --with-pid-dir=$HOME/bacula/bin/working \\
  --with-subsys-dir=$HOME/bacula/bin/working \\
  --with-mysql=$HOME/mysql \\
  --with-working-dir=$HOME/bacula/working
</pre>
<p>
If you want to install Bacula in an installation directory rather than
run it out of the build directory (as developers will do most of the
time), you should also include the --sbindir and --sysconfdir options
with appropriate paths.  Neither are necessary if you do not use "make
install" as is the case for most development work.  See below for an
example of how Kern does it. 
<h2>RedHat</h2> 
Using SQLite:
<pre> 
CFLAGS=&quot;-g -Wall&quot; ./configure \\
  --sbindir=$HOME/bacula/bin \\
  --sysconfdir=$HOME/bacula/bin \\
  --enable-smartalloc \\
  --with-sqlite=$HOME/bacula/depkgs/sqlite \\
  --with-working-dir=$HOME/bacula/working \\
  --with-pid-dir=$HOME/bacula/bin/working \\
  --with-subsys-dir=$HOME/bacula/bin/working
</pre>

or
<pre> 
CFLAGS=&quot;-g -Wall&quot; ./configure \\
  --sbindir=$HOME/bacula/bin \\
  --sysconfdir=$HOME/bacula/bin \\
  --enable-smartalloc \\
  --with-mysql=$HOME/mysql \\
  --with-working-dir=$HOME/bacula/working
  --with-pid-dir=$HOME/bacula/bin/working \\
  --with-subsys-dir=$HOME/bacula/bin/working
</pre>



<h2>Solaris</h2>
<pre>
#!/bin/sh
CFLAGS=&quot;-g&quot; ./configure \\
  --sbindir=$HOME/bacula/bin \\
  --sysconfdir=$HOME/bacula/bin \\
  --with-mysql=$HOME/mysql \\
  --enable-smartalloc \\
  --with-pid-dir=$HOME/bacula/bin/working \\
  --with-subsys-dir=$HOME/bacula/bin/working \\
  --with-working-dir=$HOME/bacula/working
</pre>

<h2>Win32</h2>
Please note that as of this time (28 April 2003), on certain
systems such as WinXP and most likely Win2K, <b>Bacula</b> will
restore files with the userid that Bacula is using namely 
<b>SYSTEM</b>. This means that you may not be able to access
those restored files until you change the owner to be your userid.
<p>
To install the binary Win32 version of the File daemon please see the
<a href="win32.html">Win32 Installation Chapter</a> in this
document.                                  

<h2><a name="Win32"></a>Windows Systems with CYGWIN Installed</h2>
<p>If you wish to build from the source, and 
if you have CYGWIN version 1.3.20 and GCC 2.95.3-5 installed, it
is possible to build the Win32 version of <b>Bacula</b> on a 
Windows machine.
Please don't try any other versions of CYGWIN or GCC as there
were known problems.  In addition, <b>Bacula</b> is designed to
be installed on a non-CYGWIN system. If you do install it
on a system with CYGWIN installed, you are on your own, and
you must take special care to install <b>Bacula</b> in the
main CYGWIN directory (normally c:\cygwin) rather than in
the root (c:\).
   
<p>To date, the Win32 version has only been build on Win98
SR2, WinMe, and WinXP Home systems
with the above CYGWIN environment and all the 
available CYGWIN tools loaded. In addition, the builds were
done running under the <b>bash</b> shell. As time permits,
we will experiment with other environments, and if any of you
do build it from source, please let us know. The current
CYGWIN environment was loaded using the CYGWIN setup.exe
program, downloading ALL the latest binaries and installing
them. 
<p>
Note, although most parts of <b>Bacula</b> build on Windows
systems, the only part that we have tested and used is the
File daemon. 
<p>
We recommend that you run the <b>./configure</b> command with
the following options:
<pre>
./configure \\
  --sbindir=/bacula/bin \\
  --sysconfdir=/bacula/bin \\
  --with-working-dir=/bacula/working \\
  --with-pid-dir=/bacula/working \\
  --with-subsys-dir=/bacula/working \\
  --enable-smartalloc
</pre>
Note, the automatic installation for Win32 is not yet written,
so most of these specifications are not really used.
<p>
After which, you can do a:
<pre>
make
</pre>
To create a binary tar release, do the following:
<pre>
cd src/filed/win32
make binary-release
</pre>
It will tell you where it has placed the binary release.
<p>
All the daemons will be built, but the only one tested to date
is the Win32 File daemon. For the other daemons, you are on
your own. It is not very probable they will work.
<p>
Finally, you should follow the installation instructions in
the <a href="win32.html">Win32 Installation</a> section of
this document, skipping the part that describes unZipping
the binary release.


<h2>Kern's Configure Script</h2>
The script that I use for building on my &quot;production&quot;
Linux machines is:
<pre>
#!/bin/sh
# This is Kern's configure script for Bacula
CFLAGS="-g -Wall" \\
  ./configure \\
    --sbindir=$HOME/bacula/bin \\
    --sysconfdir=$HOME/bacula/bin \\
    --enable-gnome \\
    --with-pid-dir=$HOME/bacula/bin/working \\
    --with-subsys-dir=$HOME/bacula/bin/working \\
    --with-mysql=$HOME/mysql \\
    --with-working-dir=$HOME/bacula/bin/working \\
    --with-dump-email=$USER \\
    --with-baseport=9101
exit 0
</pre>


Note that I define the base port as 9101, which means that
<b>Bacula</b> will use port 9101 for the Director console,
port 9102 for the File daemons, and
port 9103 for the Storage daemons.
These ports should be available on 
all systems because they have been officially
assigned to <b>Bacula</b> by IANA (Internet Assigned
Numbers Authority). We strongly recommend that you use
only these ports to prevent any conflicts with other
programs. This is in fact the default if you do not
specify a <b>--with-baseport</b> option.
<p>
You may also want to put the following entries in your
<b>/etc/services</b> file as it will make viewing the
connections made by <b>Bacula</b> easier to recognize
(i.e. netstat -a):
<pre>
bacula-dir      9101/tcp
bacula-fd       9102/tcp
bacula-sd       9103/tcp
</pre>

<h2>Building a File Daemon or Client</h2>
If you run the Director and the Storage daemon on one
machine and you wish to back up another machine, you
must have a copy of the File daemon for that machine.
If the machine and the Operating System are identical,
you can simply copy the Bacula File daemon binary
file <b>bacula-fd</b> as well as its configuration
file <b>bacula-fd.conf</b> then modify the name and
password in the conf file to be unique. Be sure to
make corresponding additions to the Director's configuration
file (<b>bacula-dir.conf</b>).
<p>If the architecture or the O/S level are different,
you will need to build a File daemon on the Client 
machine. To do so,
you can use the same <b>./configure</b> command as
you did for your main program, starting either from
a fresh copy of the source tree, or using   
<b>make&nbsp;distclean</b> before the <b>./configure</b>.
<p>
Since the File 
daemon does not access the Catalog database, you can
remove the <b>--with-mysql</b> or <b>--with-sqlite</b>
options, then add <b>--enable-client-only</b>. 
This will compile only the necessary libraries and the
client programs
and thus avoids the necessity of installing one
or another of those database programs to build the File
daemon. With the above option, you simply enter
<b>make</b> and just the client will be built.

<h2>Auto Starting the Daemons</h2>
If you wish the daemons to be automatically started and
stopped when your system is booted (a good idea), one
more step is necessary. First, the ./configure process
must recognize your system -- that is it must be
a supported platform and not <b>unknown</b>, then
you must install the platform dependent files by doing:
<pre>
(become root)
make install-autostart
</pre>
Please note, that the auto-start feature is implemented
only on systems that we officially support (currently,
FreeBSD, RedHat Linux, and Solaris), and has only been
fully tested on RedHat Linux.
<p>The <b>make install-autostart</b> will cause the appropriate startup
scripts to be installed with the necessary symbolic links.
On RedHat Linux systems,
these scripts reside in <b>/etc/rc.d/init.d/bacula-dir</b>
<b>/etc/rc.d/init.d/bacula-fd</b>, and
<b>/etc/rc.d/init.d/bacula-sd</b>. However the exact location
depends on what operating system you are using.
<p>
If you only wish to install the File daemon, you may do
so with:
<pre>
make install-autostart-fd
</pre>


<h2>Other Make Notes</h2>
To simply build a new executable in any directory, enter:
<pre>make</pre>
To clean out all the objects and binaries (including the
files named 1, 2, or 3, which Kern uses as temporary files), enter:
<pre>make clean</pre>
To really clean out everything for distribution, enter:
<pre>make distclean</pre>
note, this cleans out the Makefiles and is normally done
from the top level directory to prepare for distribution
of the source. To recover from this state,
you must redo the <b>./configure</b> in the top level directory,
since all the Makefiles will be deleted.
<p>To add a new file in a subdirectory, edit the Makefile.in
in that directory, then simply do a <b>make</b>. In most
cases, the make will rebuild the Makefile from the new Makefile.in.
In some case, you may need to issue the <b>make</b> a second time.
In extreme cases, cd to the top level directory and enter:
<b>make Makefiles</b>.
<p>To add dependencies:
<pre>make depend</pre>
The <b>make depend</b> appends the header file dependencies for each of
the object files to Makefile and Makefile.in. This command should be done
in each directory where you change the dependencies. Normally, it
only needs to be run when you add or delete source or header files.
<b>make depend</b> is normally automatically invoked during the
configuration process.
<p>To install:</p>
<pre>make install</pre>
This not normally done if you are developing <b>Bacula</b>, but
is used if you are going to run it to backup your system.

<p>
After doing a <b>make install</b> the following files will
be installed on your system (more or less). The exact files
and location (directory) for each file depends on your <b>./configure</b>
command (e.g. gnome-console and gnome-console.conf are not installed
if you do not configure GNOME. Also, if you are using SQLite instead
of mysql, some of the files will be different).
<pre>
bacula
bacula-dir
bacula-dir.conf
bacula-fd
bacula-fd.conf
bacula-sd
bacula-sd.conf
bextract
bls
bscan
btape
btraceback
btraceback.gdb
console
console.conf
create_mysql_database
dbcheck
delete_catalog_backup
drop_bacula_tables
drop_mysql_tables
fd
gnome-console
gnome-console.conf
make_bacula_tables
make_catalog_backup
make_mysql_tables
mtx-changer
query.sql
smtp
startmysql
stopmysql
</pre>

<h1>Modifying the Bacula Configuration Files</h1>
See the chapter <a href="configure.html">Configuring Bacula</a> 
in this manual for instructions on how to set <b>Bacula</b> configuration
files.

<page_prev name="Getting Started" url="quickstart.html">
<page_next name="Bacula Configuration" url="configure.html">
