git.sur5r.net Git - bacula/bacula/blob - bacula/src/cats/bdb.c

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2008 Free Software Foundation Europe e.V.
   5
   6    The main author of Bacula is Kern Sibbald, with contributions from
   7    many others, a complete list can be found in the file AUTHORS.
   8    This program is Free Software; you can redistribute it and/or
   9    modify it under the terms of version two of the GNU General Public
  10    License as published by the Free Software Foundation and included
  11    in the file LICENSE.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23    Bacula® is a registered trademark of Kern Sibbald.
  24    The licensor of Bacula is the Free Software Foundation Europe
  25    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  26    Switzerland, email:ftf@fsfeurope.org.
  27 */
  28 /*
  29  * Bacula Catalog Database routines written specifically
  30  *  for Bacula.  Note, these routines are VERY dumb and
  31  *  do not provide all the functionality of an SQL database.
  32  *  The purpose of these routines is to ensure that Bacula
  33  *  can limp along if no real database is loaded on the
  34  *  system.
  35  *
  36  *    Kern Sibbald, January MMI
  37  *
  38  *    Version $Id$
  39  *
  40  */
  41
  42
  43 /* The following is necessary so that we do not include
  44  * the dummy external definition of DB.
  45  */
  46 #define __SQL_C                       /* indicate that this is sql.c */
  47
  48 #include "bacula.h"
  49 #include "cats.h"
  50
  51 #ifdef HAVE_BACULA_DB
  52
  53 uint32_t bacula_db_version = 0;
  54
  55 int db_type = 0;
  56
  57 /* List of open databases */
  58 static BQUEUE db_list = {&db_list, &db_list};
  59 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  60
  61 /* -----------------------------------------------------------------------
  62  *
  63  *   Bacula specific defines and subroutines
  64  *
  65  * -----------------------------------------------------------------------
  66  */
  67
  68
  69 #define DB_CONTROL_FILENAME  "control.db"
  70 #define DB_JOBS_FILENAME     "jobs.db"
  71 #define DB_POOLS_FILENAME    "pools.db"
  72 #define DB_MEDIA_FILENAME    "media.db"
  73 #define DB_JOBMEDIA_FILENAME "jobmedia.db"
  74 #define DB_CLIENT_FILENAME   "client.db"
  75 #define DB_FILESET_FILENAME  "fileset.db"
  76
  77
  78 B_DB *db_init(JCR *jcr, const char *db_driver, const char *db_name, const char *db_user,
  79               const char *db_password, const char *db_address, int db_port,
  80               const char *db_socket, int mult_db_connections)
  81 {
  82    return db_init_database(jcr, db_name, db_user, db_password, db_address,
  83              db_port, db_socket, mult_db_connections);
  84 }
  85
  86
  87 dbid_list::dbid_list()
  88 {
  89    memset(this, 0, sizeof(dbid_list));
  90    max_ids = 1000;
  91    DBId = (DBId_t *)malloc(max_ids * sizeof(DBId_t));
  92    num_ids = num_seen = tot_ids = 0;
  93    PurgedFiles = NULL;
  94 }
  95
  96 dbid_list::~dbid_list()
  97 {
  98    free(DBId);
  99 }
 100
 101 static POOLMEM *make_filename(B_DB *mdb, const char *name)
 102 {
 103    char sep;
 104    POOLMEM *dbf;
 105
 106    dbf = get_pool_memory(PM_FNAME);
 107    if (IsPathSeparator(working_directory[strlen(working_directory)-1])) {
 108       sep = 0;
 109    } else {
 110       sep = '/';
 111    }
 112    Mmsg(dbf, "%s%c%s-%s", working_directory, sep, mdb->db_name, name);
 113    return dbf;
 114 }
 115
 116 int bdb_write_control_file(B_DB *mdb)
 117 {
 118    mdb->control.time = time(NULL);
 119    lseek(mdb->cfd, 0, SEEK_SET);
 120    if (write(mdb->cfd, &mdb->control, sizeof(mdb->control)) != sizeof(mdb->control)) {
 121       Mmsg1(&mdb->errmsg, "Error writing control file. ERR=%s\n", strerror(errno));
 122       Emsg0(M_FATAL, 0, mdb->errmsg);
 123       return 0;
 124    }
 125    return 1;
 126 }
 127
 128 /*
 129  * Retrieve database type
 130  */
 131 const char *
 132 db_get_type(void)
 133 {
 134    return "Internal";
 135 }
 136
 137 /*
 138  * Initialize database data structure. In principal this should
 139  * never have errors, or it is really fatal.
 140  */
 141 B_DB *
 142 db_init_database(JCR *jcr, char const *db_name, char const *db_user, char const *db_password,
 143                  char const *db_address, int db_port, char const *db_socket,
 144                  int mult_db_connections)
 145 {
 146    B_DB *mdb;
 147    P(mutex);                          /* lock DB queue */
 148    /* Look to see if DB already open */
 149    for (mdb=NULL; (mdb=(B_DB *)qnext(&db_list, &mdb->bq)); ) {
 150       if (strcmp(mdb->db_name, db_name) == 0) {
 151          Dmsg2(200, "DB REopen %d %s\n", mdb->ref_count, db_name);
 152          mdb->ref_count++;
 153          V(mutex);
 154          return mdb;                  /* already open */
 155       }
 156    }
 157
 158    Dmsg0(200, "db_open first time\n");
 159    mdb = (B_DB *)malloc(sizeof(B_DB));
 160    memset(mdb, 0, sizeof(B_DB));
 161    Dmsg0(200, "DB struct init\n");
 162    mdb->db_name = bstrdup(db_name);
 163    mdb->errmsg = get_pool_memory(PM_EMSG);
 164    *mdb->errmsg = 0;
 165    mdb->cmd = get_pool_memory(PM_EMSG);  /* command buffer */
 166    mdb->ref_count = 1;
 167    mdb->cached_path = get_pool_memory(PM_FNAME);
 168    mdb->cached_path_id = 0;
 169    qinsert(&db_list, &mdb->bq);       /* put db in list */
 170    Dmsg0(200, "Done db_open_database()\n");
 171    mdb->cfd = -1;
 172    V(mutex);
 173    Jmsg(jcr, M_WARNING, 0, _("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"));
 174    Jmsg(jcr, M_WARNING, 0, _("WARNING!!!! The Internal Database is NOT OPERATIONAL!\n"));
 175    Jmsg(jcr, M_WARNING, 0, _("You should use SQLite, PostgreSQL, or MySQL\n"));
 176
 177    return mdb;
 178 }
 179
 180 /*
 181  * Now actually open the database.  This can generate errors,
 182  * which are returned in the errmsg
 183  */
 184 int
 185 db_open_database(JCR *jcr, B_DB *mdb)
 186 {
 187    char *dbf;
 188    int fd, badctl;
 189    off_t filend;
 190    int errstat;
 191
 192    Dmsg1(200, "db_open_database() %s\n", mdb->db_name);
 193
 194    P(mutex);
 195
 196    if ((errstat=rwl_init(&mdb->lock)) != 0) {
 197       Mmsg1(&mdb->errmsg, _("Unable to initialize DB lock. ERR=%s\n"), strerror(errstat));
 198       V(mutex);
 199       return 0;
 200    }
 201
 202    Dmsg0(200, "make_filename\n");
 203    dbf = make_filename(mdb, DB_CONTROL_FILENAME);
 204    mdb->cfd = open(dbf, O_CREAT|O_RDWR, 0600);
 205    free_memory(dbf);
 206    if (mdb->cfd < 0) {
 207       Mmsg2(&mdb->errmsg, _("Unable to open Catalog DB control file %s: ERR=%s\n"),
 208          dbf, strerror(errno));
 209       V(mutex);
 210       return 0;
 211    }
 212    Dmsg0(200, "DB open\n");
 213    /* See if the file was previously written */
 214    filend = lseek(mdb->cfd, 0, SEEK_END);
 215    if (filend == 0) {                 /* No, initialize everything */
 216       Dmsg0(200, "Init DB files\n");
 217       memset(&mdb->control, 0, sizeof(mdb->control));
 218       mdb->control.bdb_version = BDB_VERSION;
 219       bdb_write_control_file(mdb);
 220
 221       /* Create Jobs File */
 222       dbf = make_filename(mdb, DB_JOBS_FILENAME);
 223       fd = open(dbf, O_CREAT|O_RDWR, 0600);
 224       free_memory(dbf);
 225       close(fd);
 226
 227       /* Create Pools File */
 228       dbf = make_filename(mdb, DB_POOLS_FILENAME);
 229       fd = open(dbf, O_CREAT|O_RDWR, 0600);
 230       free_memory(dbf);
 231       close(fd);
 232
 233       /* Create Media File */
 234       dbf = make_filename(mdb, DB_MEDIA_FILENAME);
 235       fd = open(dbf, O_CREAT|O_RDWR, 0600);
 236       free_memory(dbf);
 237       close(fd);
 238
 239       /* Create JobMedia File */
 240       dbf = make_filename(mdb, DB_JOBMEDIA_FILENAME);
 241       fd = open(dbf, O_CREAT|O_RDWR, 0600);
 242       free_memory(dbf);
 243       close(fd);
 244
 245       /* Create Client File */
 246       dbf = make_filename(mdb, DB_CLIENT_FILENAME);
 247       fd = open(dbf, O_CREAT|O_RDWR, 0600);
 248       free_memory(dbf);
 249       close(fd);
 250
 251       /* Create FileSet File */
 252       dbf = make_filename(mdb, DB_FILESET_FILENAME);
 253       fd = open(dbf, O_CREAT|O_RDWR, 0600);
 254       free_memory(dbf);
 255       close(fd);
 256    }
 257
 258    Dmsg0(200, "Read control file\n");
 259    badctl = 0;
 260    lseek(mdb->cfd, 0, SEEK_SET);      /* seek to begining of control file */
 261    if (read(mdb->cfd, &mdb->control, sizeof(mdb->control)) != sizeof(mdb->control)) {
 262       Mmsg1(&mdb->errmsg, _("Error reading catalog DB control file. ERR=%s\n"), strerror(errno));
 263       badctl = 1;
 264    } else if (mdb->control.bdb_version != BDB_VERSION) {
 265       Mmsg2(&mdb->errmsg, _("Error, catalog DB control file wrong version. "
 266 "Wanted %d, got %d\n"
 267 "Please reinitialize the working directory.\n"),
 268          BDB_VERSION, mdb->control.bdb_version);
 269       badctl = 1;
 270    }
 271    bacula_db_version = mdb->control.bdb_version;
 272    if (badctl) {
 273       V(mutex);
 274       return 0;
 275    }
 276    V(mutex);
 277    return 1;
 278 }
 279
 280 void db_close_database(JCR *jcr, B_DB *mdb)
 281 {
 282    P(mutex);
 283    mdb->ref_count--;
 284    if (mdb->ref_count == 0) {
 285       qdchain(&mdb->bq);
 286       /*  close file descriptors */
 287       if (mdb->cfd >= 0) {
 288          close(mdb->cfd);
 289       }
 290       free(mdb->db_name);
 291       if (mdb->jobfd) {
 292          fclose(mdb->jobfd);
 293       }
 294       if (mdb->poolfd) {
 295          fclose(mdb->poolfd);
 296       }
 297       if (mdb->mediafd) {
 298          fclose(mdb->mediafd);
 299       }
 300       if (mdb->jobmediafd) {
 301          fclose(mdb->jobmediafd);
 302       }
 303       if (mdb->clientfd) {
 304          fclose(mdb->clientfd);
 305       }
 306       if (mdb->filesetfd) {
 307          fclose(mdb->filesetfd);
 308       }
 309       rwl_destroy(&mdb->lock);
 310       free_pool_memory(mdb->errmsg);
 311       free_pool_memory(mdb->cmd);
 312       free_pool_memory(mdb->cached_path);
 313       free(mdb);
 314    }
 315    V(mutex);
 316 }
 317
 318 void db_thread_cleanup()
 319 { }
 320
 321
 322 void db_escape_string(JCR *jcr, B_DB *db, char *snew, char *old, int len)
 323 {
 324    memset(snew, 0, len);
 325    bstrncpy(snew, old, len);
 326 }
 327
 328 char *db_strerror(B_DB *mdb)
 329 {
 330    return mdb->errmsg;
 331 }
 332
 333 bool db_sql_query(B_DB *mdb, char const *query, DB_RESULT_HANDLER *result_handler, void *ctx)
 334 {
 335    return true;
 336 }
 337
 338 /*
 339  * Open the Jobs file for reading/writing
 340  */
 341 int bdb_open_jobs_file(B_DB *mdb)
 342 {
 343    char *dbf;
 344
 345    if (!mdb->jobfd) {
 346       dbf = make_filename(mdb, DB_JOBS_FILENAME);
 347       mdb->jobfd = fopen(dbf, "r+b");
 348       if (!mdb->jobfd) {
 349          Mmsg2(&mdb->errmsg, "Error opening DB Jobs file %s: ERR=%s\n",
 350             dbf, strerror(errno));
 351          Emsg0(M_FATAL, 0, mdb->errmsg);
 352          free_memory(dbf);
 353          return 0;
 354       }
 355       free_memory(dbf);
 356    }
 357    return 1;
 358 }
 359
 360 /*
 361  * Open the JobMedia file for reading/writing
 362  */
 363 int bdb_open_jobmedia_file(B_DB *mdb)
 364 {
 365    char *dbf;
 366
 367    if (!mdb->jobmediafd) {
 368       dbf = make_filename(mdb, DB_JOBMEDIA_FILENAME);
 369       mdb->jobmediafd = fopen(dbf, "r+b");
 370       if (!mdb->jobmediafd) {
 371          Mmsg2(&mdb->errmsg, "Error opening DB JobMedia file %s: ERR=%s\n",
 372             dbf, strerror(errno));
 373          Emsg0(M_FATAL, 0, mdb->errmsg);
 374          free_memory(dbf);
 375          return 0;
 376       }
 377       free_memory(dbf);
 378    }
 379    return 1;
 380 }
 381
 382
 383 /*
 384  * Open the Pools file for reading/writing
 385  */
 386 int bdb_open_pools_file(B_DB *mdb)
 387 {
 388    char *dbf;
 389
 390    if (!mdb->poolfd) {
 391       dbf = make_filename(mdb, DB_POOLS_FILENAME);
 392       mdb->poolfd = fopen(dbf, "r+b");
 393       if (!mdb->poolfd) {
 394          Mmsg2(&mdb->errmsg, "Error opening DB Pools file %s: ERR=%s\n",
 395             dbf, strerror(errno));
 396          Emsg0(M_FATAL, 0, mdb->errmsg);
 397          free_memory(dbf);
 398          return 0;
 399       }
 400       Dmsg1(200, "Opened pool file %s\n", dbf);
 401       free_memory(dbf);
 402    }
 403    return 1;
 404 }
 405
 406 /*
 407  * Open the Client file for reading/writing
 408  */
 409 int bdb_open_client_file(B_DB *mdb)
 410 {
 411    char *dbf;
 412
 413    if (!mdb->clientfd) {
 414       dbf = make_filename(mdb, DB_CLIENT_FILENAME);
 415       mdb->clientfd = fopen(dbf, "r+b");
 416       if (!mdb->clientfd) {
 417          Mmsg2(&mdb->errmsg, "Error opening DB Clients file %s: ERR=%s\n",
 418             dbf, strerror(errno));
 419          Emsg0(M_FATAL, 0, mdb->errmsg);
 420          free_memory(dbf);
 421          return 0;
 422       }
 423       free_memory(dbf);
 424    }
 425    return 1;
 426 }
 427
 428 /*
 429  * Open the FileSet file for reading/writing
 430  */
 431 int bdb_open_fileset_file(B_DB *mdb)
 432 {
 433    char *dbf;
 434
 435    if (!mdb->filesetfd) {
 436       dbf = make_filename(mdb, DB_CLIENT_FILENAME);
 437       mdb->filesetfd = fopen(dbf, "r+b");
 438       if (!mdb->filesetfd) {
 439          Mmsg2(&mdb->errmsg, "Error opening DB FileSet file %s: ERR=%s\n",
 440             dbf, strerror(errno));
 441          Emsg0(M_FATAL, 0, mdb->errmsg);
 442          free_memory(dbf);
 443          return 0;
 444       }
 445       free_memory(dbf);
 446    }
 447    return 1;
 448 }
 449
 450
 451
 452 /*
 453  * Open the Media file for reading/writing
 454  */
 455 int bdb_open_media_file(B_DB *mdb)
 456 {
 457    char *dbf;
 458
 459    if (!mdb->mediafd) {
 460       dbf = make_filename(mdb, DB_MEDIA_FILENAME);
 461       mdb->mediafd = fopen(dbf, "r+b");
 462       if (!mdb->mediafd) {
 463          Mmsg2(&mdb->errmsg, "Error opening DB Media file %s: ERR=%s\n",
 464             dbf, strerror(errno));
 465          free_memory(dbf);
 466          return 0;
 467       }
 468       free_memory(dbf);
 469    }
 470    return 1;
 471 }
 472
 473
 474 void _db_lock(const char *file, int line, B_DB *mdb)
 475 {
 476    int errstat;
 477    if ((errstat=rwl_writelock(&mdb->lock)) != 0) {
 478       e_msg(file, line, M_ABORT, 0, "rwl_writelock failure. ERR=%s\n",
 479            strerror(errstat));
 480    }
 481 }
 482
 483 void _db_unlock(const char *file, int line, B_DB *mdb)
 484 {
 485    int errstat;
 486    if ((errstat=rwl_writeunlock(&mdb->lock)) != 0) {
 487       e_msg(file, line, M_ABORT, 0, "rwl_writeunlock failure. ERR=%s\n",
 488            strerror(errstat));
 489    }
 490 }
 491
 492 /*
 493  * Start a transaction. This groups inserts and makes things
 494  *  much more efficient. Usually started when inserting
 495  *  file attributes.
 496  */
 497 void db_start_transaction(JCR *jcr, B_DB *mdb)
 498 {
 499 }
 500
 501 void db_end_transaction(JCR *jcr, B_DB *mdb)
 502 {
 503 }
 504
 505 bool db_update_storage_record(JCR *jcr, B_DB *mdb, STORAGE_DBR *sr)
 506 { return true; }
 507
 508 void
 509 db_list_pool_records(JCR *jcr, B_DB *mdb, POOL_DBR *pdbr,
 510                      DB_LIST_HANDLER *sendit, void *ctx, e_list_type type)
 511 { }
 512
 513 int db_int64_handler(void *ctx, int num_fields, char **row)
 514 { return 0; }
 515
 516 bool db_create_file_attributes_record(JCR *jcr, B_DB *mdb, ATTR_DBR *ar)
 517 {
 518    return true;
 519 }
 520
 521 int db_create_file_item(JCR *jcr, B_DB *mdb, ATTR_DBR *ar)
 522 {
 523    return 1;
 524 }
 525
 526
 527 /*
 528  * Create a new record for the Job
 529  *   This record is created at the start of the Job,
 530  *   it is updated in bdb_update.c when the Job terminates.
 531  *
 532  * Returns: 0 on failure
 533  *          1 on success
 534  */
 535 bool db_create_job_record(JCR *jcr, B_DB *mdb, JOB_DBR *jr)
 536 {
 537    return 0;
 538 }
 539
 540 /* Create a JobMedia record for Volume used this job
 541  * Returns: 0 on failure
 542  *          record-id on success
 543  */
 544 bool db_create_jobmedia_record(JCR *jcr, B_DB *mdb, JOBMEDIA_DBR *jm)
 545 {
 546    return 0;
 547 }
 548
 549
 550 /*
 551  *  Create a unique Pool record
 552  * Returns: 0 on failure
 553  *          1 on success
 554  */
 555 bool db_create_pool_record(JCR *jcr, B_DB *mdb, POOL_DBR *pr)
 556 {
 557    return 0;
 558 }
 559
 560 bool db_create_device_record(JCR *jcr, B_DB *mdb, DEVICE_DBR *dr)
 561 { return false; }
 562
 563 bool db_create_storage_record(JCR *jcr, B_DB *mdb, STORAGE_DBR *dr)
 564 { return false; }
 565
 566 bool db_create_mediatype_record(JCR *jcr, B_DB *mdb, MEDIATYPE_DBR *dr)
 567 { return false; }
 568
 569
 570 /*
 571  * Create Unique Media record.  This record
 572  *   contains all the data pertaining to a specific
 573  *   Volume.
 574  *
 575  * Returns: 0 on failure
 576  *          1 on success
 577  */
 578 int db_create_media_record(JCR *jcr, B_DB *mdb, MEDIA_DBR *mr)
 579 {
 580    return 0;
 581 }
 582
 583 int db_create_client_record(JCR *jcr, B_DB *mdb, CLIENT_DBR *cr)
 584 {
 585    return 0;
 586 }
 587
 588 bool db_create_fileset_record(JCR *jcr, B_DB *mdb, FILESET_DBR *fsr)
 589 {
 590    return false;
 591 }
 592
 593 int db_create_counter_record(JCR *jcr, B_DB *mdb, COUNTER_DBR *cr)
 594 { return 0; }
 595
 596 bool db_write_batch_file_records(JCR *jcr) { return false; }
 597 bool my_batch_start(JCR *jcr, B_DB *mdb) { return false; }
 598 bool my_batch_end(JCR *jcr, B_DB *mdb, const char *error) { return false; }
 599 bool my_batch_insert(JCR *jcr, B_DB *mdb, ATTR_DBR *ar) { return false; }
 600
 601 int db_delete_pool_record(JCR *jcr, B_DB *mdb, POOL_DBR *pr)
 602 {
 603    return 0;
 604 }
 605
 606 int db_delete_media_record(JCR *jcr, B_DB *mdb, MEDIA_DBR *mr)
 607 {
 608    return 0;
 609 }
 610
 611 bool db_find_job_start_time(JCR *jcr, B_DB *mdb, JOB_DBR *jr, POOLMEM **stime)
 612 {
 613    return 0;
 614 }
 615
 616 int
 617 db_find_next_volume(JCR *jcr, B_DB *mdb, int item, bool InChanger, MEDIA_DBR *mr)
 618 {
 619    return 0;
 620 }
 621
 622 bool
 623 db_find_last_jobid(JCR *jcr, B_DB *mdb, const char *Name, JOB_DBR *jr)
 624 { return false; }
 625
 626 bool
 627 db_find_failed_job_since(JCR *jcr, B_DB *mdb, JOB_DBR *jr, POOLMEM *stime, int &JobLevel)
 628 { return false; }
 629
 630 bool db_get_job_record(JCR *jcr, B_DB *mdb, JOB_DBR *jr)
 631 {
 632    return 0;
 633 }
 634
 635 int db_get_num_pool_records(JCR *jcr, B_DB *mdb)
 636 {
 637    return -1;
 638 }
 639
 640 int db_get_pool_ids(JCR *jcr, B_DB *mdb, int *num_ids, uint32_t *ids[])
 641 { return 0; }
 642
 643 bool db_get_pool_record(JCR *jcr, B_DB *mdb, POOL_DBR *pr)
 644 { return 0; }
 645
 646 int db_get_num_media_records(JCR *jcr, B_DB *mdb)
 647 { return -1; }
 648
 649 bool db_get_media_ids(JCR *jcr, B_DB *mdb, uint32_t PoolId, int *num_ids, uint32_t *ids[])
 650 { return false; }
 651
 652 bool db_get_media_record(JCR *jcr, B_DB *mdb, MEDIA_DBR *mr)
 653 { return false; }
 654
 655 int db_get_job_volume_names(JCR *jcr, B_DB *mdb, uint32_t JobId, POOLMEM **VolumeNames)
 656 { return 0; }
 657
 658 int db_get_client_record(JCR *jcr, B_DB *mdb, CLIENT_DBR *cr)
 659 { return 0; }
 660
 661 int db_get_fileset_record(JCR *jcr, B_DB *mdb, FILESET_DBR *fsr)
 662 { return 0; }
 663
 664 bool db_get_query_dbids(JCR *jcr, B_DB *mdb, POOL_MEM &query, dbid_list &ids)
 665 { return false; }
 666
 667 int db_get_file_attributes_record(JCR *jcr, B_DB *mdb, char *fname, JOB_DBR *jr, FILE_DBR *fdbr)
 668 { return 0; }
 669
 670 int db_get_job_volume_parameters(JCR *jcr, B_DB *mdb, uint32_t JobId, VOL_PARAMS **VolParams)
 671 { return 0; }
 672
 673 int db_get_client_ids(JCR *jcr, B_DB *mdb, int *num_ids, uint32_t *ids[])
 674 { return 0; }
 675
 676 int db_get_counter_record(JCR *jcr, B_DB *mdb, COUNTER_DBR *cr)
 677 { return 0; }
 678
 679 int db_list_sql_query(JCR *jcr, B_DB *mdb, const char *query, DB_LIST_HANDLER *sendit,
 680                       void *ctx, int verbose)
 681 { return 0; }
 682
 683 void db_list_pool_records(JCR *jcr, B_DB *mdb, DB_LIST_HANDLER *sendit, void *ctx)
 684 { }
 685
 686 void db_list_media_records(JCR *jcr, B_DB *mdb, MEDIA_DBR *mdbr,
 687                            DB_LIST_HANDLER *sendit, void *ctx)
 688 { }
 689
 690 void db_list_jobmedia_records(JCR *jcr, B_DB *mdb, uint32_t JobId,
 691                               DB_LIST_HANDLER *sendit, void *ctx)
 692 {  }
 693
 694 void db_list_job_records(JCR *jcr, B_DB *mdb, JOB_DBR *jr,
 695                          DB_LIST_HANDLER *sendit, void *ctx)
 696 { }
 697
 698 void db_list_job_totals(JCR *jcr, B_DB *mdb, JOB_DBR *jr,
 699                         DB_LIST_HANDLER *sendit, void *ctx)
 700 { }
 701
 702 void db_list_files_for_job(JCR *jcr, B_DB *mdb, uint32_t jobid, DB_LIST_HANDLER *sendit, void *ctx)
 703 { }
 704
 705 void db_list_client_records(JCR *jcr, B_DB *mdb, DB_LIST_HANDLER *sendit, void *ctx)
 706 { }
 707
 708 int db_list_sql_query(JCR *jcr, B_DB *mdb, const char *query, DB_LIST_HANDLER *sendit,
 709                       void *ctx, int verbose, e_list_type type)
 710 {
 711    return 0;
 712 }
 713
 714 void
 715 db_list_pool_records(JCR *jcr, B_DB *mdb, DB_LIST_HANDLER *sendit, void *ctx, e_list_type type)
 716 { }
 717
 718 void
 719 db_list_media_records(JCR *jcr, B_DB *mdb, MEDIA_DBR *mdbr,
 720                       DB_LIST_HANDLER *sendit, void *ctx, e_list_type type)
 721 { }
 722
 723 void db_list_jobmedia_records(JCR *jcr, B_DB *mdb, uint32_t JobId,
 724                               DB_LIST_HANDLER *sendit, void *ctx, e_list_type type)
 725 { }
 726
 727 void
 728 db_list_job_records(JCR *jcr, B_DB *mdb, JOB_DBR *jr, DB_LIST_HANDLER *sendit,
 729                     void *ctx, e_list_type type)
 730 { }
 731
 732 void
 733 db_list_client_records(JCR *jcr, B_DB *mdb, DB_LIST_HANDLER *sendit, void *ctx, e_list_type type)
 734 { }
 735
 736 bool db_update_job_start_record(JCR *jcr, B_DB *mdb, JOB_DBR *jr)
 737 {
 738    return false;
 739 }
 740
 741 /*
 742  * This is called at Job termination time to add all the
 743  * other fields to the job record.
 744  */
 745 int db_update_job_end_record(JCR *jcr, B_DB *mdb, JOB_DBR *jr, bool stats_enabled)
 746 {
 747    return 0;
 748 }
 749
 750
 751 int db_update_media_record(JCR *jcr, B_DB *mdb, MEDIA_DBR *mr)
 752 {
 753    return 0;
 754 }
 755
 756 int db_update_pool_record(JCR *jcr, B_DB *mdb, POOL_DBR *pr)
 757 {
 758    return 0;
 759 }
 760
 761 int db_add_digest_to_file_record(JCR *jcr, B_DB *mdb, FileId_t FileId, char *digest, int type)
 762 {
 763    return 1;
 764 }
 765
 766 int db_mark_file_record(JCR *jcr, B_DB *mdb, FileId_t FileId, JobId_t JobId)
 767 {
 768    return 1;
 769 }
 770
 771 int db_update_client_record(JCR *jcr, B_DB *mdb, CLIENT_DBR *cr)
 772 {
 773    return 1;
 774 }
 775
 776 int db_update_counter_record(JCR *jcr, B_DB *mdb, COUNTER_DBR *cr)
 777 {
 778    return 0;
 779 }
 780
 781 int db_update_media_defaults(JCR *jcr, B_DB *mdb, MEDIA_DBR *mr)
 782 {
 783    return 1;
 784 }
 785
 786 void db_make_inchanger_unique(JCR *jcr, B_DB *mdb, MEDIA_DBR *mr)
 787 {
 788   return;
 789 }
 790
 791
 792 #endif /* HAVE_BACULA_DB */