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

   1 /*
   2  * Bacula Catalog Database routines written specifically
   3  *  for Bacula.  Note, these routines are VERY dumb and
   4  *  do not provide all the functionality of an SQL database.
   5  *  The purpose of these routines is to ensure that Bacula
   6  *  can limp along if no real database is loaded on the
   7  *  system.
   8  *
   9  *    Kern Sibbald, January MMI
  10  *
  11  *    Version $Id$
  12  *
  13  */
  14
  15
  16 /*
  17    Copyright (C) 2000-2003 Kern Sibbald and John Walker
  18
  19    This program is free software; you can redistribute it and/or
  20    modify it under the terms of the GNU General Public License as
  21    published by the Free Software Foundation; either version 2 of
  22    the License, or (at your option) any later version.
  23
  24    This program is distributed in the hope that it will be useful,
  25    but WITHOUT ANY WARRANTY; without even the implied warranty of
  26    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  27    General Public License for more details.
  28
  29    You should have received a copy of the GNU General Public
  30    License along with this program; if not, write to the Free
  31    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  32    MA 02111-1307, USA.
  33
  34  */
  35
  36
  37 /* The following is necessary so that we do not include
  38  * the dummy external definition of DB.
  39  */
  40 #define __SQL_C                       /* indicate that this is sql.c */
  41
  42 #include "bacula.h"
  43 #include "cats.h"
  44
  45 #ifdef HAVE_BACULA_DB
  46
  47 /* Forward referenced functions */
  48
  49 extern char *working_directory;
  50
  51 /* List of open databases */
  52 static BQUEUE db_list = {&db_list, &db_list};
  53 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  54
  55 /* -----------------------------------------------------------------------
  56  *
  57  *   Bacula specific defines and subroutines
  58  *
  59  * -----------------------------------------------------------------------
  60  */
  61
  62
  63 #define DB_CONTROL_FILENAME  "control.db"
  64 #define DB_JOBS_FILENAME     "jobs.db"
  65 #define DB_POOLS_FILENAME    "pools.db"
  66 #define DB_MEDIA_FILENAME    "media.db"
  67 #define DB_JOBMEDIA_FILENAME "jobmedia.db"
  68 #define DB_CLIENT_FILENAME   "client.db"
  69 #define DB_FILESET_FILENAME  "fileset.db"
  70
  71 static POOLMEM *make_filename(B_DB *mdb, char *name)
  72 {
  73    char sep;
  74    POOLMEM *dbf;
  75
  76    dbf = get_pool_memory(PM_FNAME);
  77    if (working_directory[strlen(working_directory)-1] == '/') {
  78       sep = 0;
  79    } else {
  80       sep = '/';
  81    }
  82    Mmsg(&dbf, "%s%c%s-%s", working_directory, sep, mdb->db_name, name);
  83    return dbf;
  84 }
  85
  86 int bdb_write_control_file(B_DB *mdb)
  87 {
  88    mdb->control.time = time(NULL);
  89    lseek(mdb->cfd, 0, SEEK_SET);
  90    if (write(mdb->cfd, &mdb->control, sizeof(mdb->control)) != sizeof(mdb->control)) {
  91       Mmsg1(&mdb->errmsg, "Error writing control file. ERR=%s\n", strerror(errno));
  92       Emsg0(M_FATAL, 0, mdb->errmsg);
  93       return 0;
  94    }
  95    return 1;
  96 }
  97
  98 /*
  99  * Initialize database data structure. In principal this should
 100  * never have errors, or it is really fatal.
 101  */
 102 B_DB *
 103 db_init_database(void *jcr, char *db_name, char *db_user, char *db_password)
 104 {
 105    B_DB *mdb;
 106    P(mutex);                          /* lock DB queue */
 107    /* Look to see if DB already open */
 108    for (mdb=NULL; (mdb=(B_DB *)qnext(&db_list, &mdb->bq)); ) {
 109       if (strcmp(mdb->db_name, db_name) == 0) {
 110          Dmsg2(200, "DB REopen %d %s\n", mdb->ref_count, db_name);
 111          mdb->ref_count++;
 112          V(mutex);
 113          return mdb;                  /* already open */
 114       }
 115    }
 116    Dmsg0(200, "db_open first time\n");
 117    mdb = (B_DB *)malloc(sizeof(B_DB));
 118    memset(mdb, 0, sizeof(B_DB));
 119    Dmsg0(200, "DB struct init\n");
 120    mdb->db_name = bstrdup(db_name);
 121    mdb->errmsg = get_pool_memory(PM_EMSG);
 122    *mdb->errmsg = 0;
 123    mdb->cmd = get_pool_memory(PM_EMSG);  /* command buffer */
 124    mdb->ref_count = 1;
 125    mdb->cached_path = get_pool_memory(PM_FNAME);
 126    mdb->cached_path_id = 0;
 127    qinsert(&db_list, &mdb->bq);       /* put db in list */
 128    Dmsg0(200, "Done db_open_database()\n");
 129    mdb->cfd = -1;
 130    V(mutex);
 131    Jmsg(jcr, M_WARNING, 0, _("WARNING!!!! The Internal Database is for TESTING ONLY!\n"));
 132    Jmsg(jcr, M_WARNING, 0, _("You should use either SQLite or MySQL\n"));
 133
 134    return mdb;
 135 }
 136
 137 /*
 138  * Now actually open the database.  This can generate errors,
 139  * which are returned in the errmsg
 140  */
 141 int
 142 db_open_database(void *jcr, B_DB *mdb)
 143 {
 144    char *dbf;
 145    int fd, badctl;
 146    off_t filend;
 147    int errstat;
 148
 149    Dmsg1(200, "db_open_database() %s\n", mdb->db_name);
 150
 151    P(mutex);
 152
 153    if ((errstat=rwl_init(&mdb->lock)) != 0) {
 154       Mmsg1(&mdb->errmsg, _("Unable to initialize DB lock. ERR=%s\n"), strerror(errstat));
 155       V(mutex);
 156       return 0;
 157    }
 158
 159    Dmsg0(200, "make_filename\n");
 160    dbf = make_filename(mdb, DB_CONTROL_FILENAME);
 161    mdb->cfd = open(dbf, O_CREAT|O_RDWR, 0600);
 162    free_memory(dbf);
 163    if (mdb->cfd < 0) {
 164       Mmsg2(&mdb->errmsg, _("Unable to open Catalog DB control file %s: ERR=%s\n"),
 165          dbf, strerror(errno));
 166       V(mutex);
 167       return 0;
 168    }
 169    Dmsg0(200, "DB open\n");
 170    /* See if the file was previously written */
 171    filend = lseek(mdb->cfd, 0, SEEK_END);
 172    if (filend == 0) {                 /* No, initialize everything */
 173       Dmsg0(200, "Init DB files\n");
 174       memset(&mdb->control, 0, sizeof(mdb->control));
 175       mdb->control.bdb_version = BDB_VERSION;
 176       bdb_write_control_file(mdb);
 177
 178       /* Create Jobs File */
 179       dbf = make_filename(mdb, DB_JOBS_FILENAME);
 180       fd = open(dbf, O_CREAT|O_RDWR, 0600);
 181       free_memory(dbf);
 182       close(fd);
 183
 184       /* Create Pools File */
 185       dbf = make_filename(mdb, DB_POOLS_FILENAME);
 186       fd = open(dbf, O_CREAT|O_RDWR, 0600);
 187       free_memory(dbf);
 188       close(fd);
 189
 190       /* Create Media File */
 191       dbf = make_filename(mdb, DB_MEDIA_FILENAME);
 192       fd = open(dbf, O_CREAT|O_RDWR, 0600);
 193       free_memory(dbf);
 194       close(fd);
 195
 196       /* Create JobMedia File */
 197       dbf = make_filename(mdb, DB_JOBMEDIA_FILENAME);
 198       fd = open(dbf, O_CREAT|O_RDWR, 0600);
 199       free_memory(dbf);
 200       close(fd);
 201
 202       /* Create Client File */
 203       dbf = make_filename(mdb, DB_CLIENT_FILENAME);
 204       fd = open(dbf, O_CREAT|O_RDWR, 0600);
 205       free_memory(dbf);
 206       close(fd);
 207
 208       /* Create FileSet File */
 209       dbf = make_filename(mdb, DB_FILESET_FILENAME);
 210       fd = open(dbf, O_CREAT|O_RDWR, 0600);
 211       free_memory(dbf);
 212       close(fd);
 213    }
 214
 215    Dmsg0(200, "Read control file\n");
 216    badctl = 0;
 217    lseek(mdb->cfd, 0, SEEK_SET);      /* seek to begining of control file */
 218    if (read(mdb->cfd, &mdb->control, sizeof(mdb->control)) != sizeof(mdb->control)) {
 219       Mmsg1(&mdb->errmsg, _("Error reading catalog DB control file. ERR=%s\n"), strerror(errno));
 220       badctl = 1;
 221    } else if (mdb->control.bdb_version != BDB_VERSION) {
 222       Mmsg2(&mdb->errmsg, _("Error, catalog DB control file wrong version. \
 223 Wanted %d, got %d\n\
 224 Please reinitialize the working directory.\n"),
 225          BDB_VERSION, mdb->control.bdb_version);
 226       badctl = 1;
 227    }
 228    if (badctl) {
 229       V(mutex);
 230       return 0;
 231    }
 232    V(mutex);
 233    return 1;
 234 }
 235
 236 void db_close_database(void *jcr, B_DB *mdb)
 237 {
 238    P(mutex);
 239    mdb->ref_count--;
 240    if (mdb->ref_count == 0) {
 241       qdchain(&mdb->bq);
 242       /*  close file descriptors */
 243       if (mdb->cfd >= 0) {
 244          close(mdb->cfd);
 245       }
 246       free(mdb->db_name);
 247       if (mdb->jobfd) {
 248          fclose(mdb->jobfd);
 249       }
 250       if (mdb->poolfd) {
 251          fclose(mdb->poolfd);
 252       }
 253       if (mdb->mediafd) {
 254          fclose(mdb->mediafd);
 255       }
 256       if (mdb->jobmediafd) {
 257          fclose(mdb->jobmediafd);
 258       }
 259       if (mdb->clientfd) {
 260          fclose(mdb->clientfd);
 261       }
 262       if (mdb->filesetfd) {
 263          fclose(mdb->filesetfd);
 264       }
 265 /*    pthread_mutex_destroy(&mdb->mutex); */
 266       rwl_destroy(&mdb->lock);
 267       free_pool_memory(mdb->errmsg);
 268       free_pool_memory(mdb->cmd);
 269       free_pool_memory(mdb->cached_path);
 270       free(mdb);
 271    }
 272    V(mutex);
 273 }
 274
 275
 276 void db_escape_string(char *snew, char *old, int len)
 277 {
 278    strcpy(snew, old);
 279 }
 280
 281 char *db_strerror(B_DB *mdb)
 282 {
 283    return mdb->errmsg;
 284 }
 285
 286 int db_sql_query(B_DB *mdb, char *query, DB_RESULT_HANDLER *result_handler, void *ctx)
 287 {
 288    return 1;
 289 }
 290
 291 /*
 292  * Open the Jobs file for reading/writing
 293  */
 294 int bdb_open_jobs_file(B_DB *mdb)
 295 {
 296    char *dbf;
 297
 298    if (!mdb->jobfd) {
 299       dbf = make_filename(mdb, DB_JOBS_FILENAME);
 300       mdb->jobfd = fopen(dbf, "r+");
 301       if (!mdb->jobfd) {
 302          Mmsg2(&mdb->errmsg, "Error opening DB Jobs file %s: ERR=%s\n",
 303             dbf, strerror(errno));
 304          Emsg0(M_FATAL, 0, mdb->errmsg);
 305          free_memory(dbf);
 306          return 0;
 307       }
 308       free_memory(dbf);
 309    }
 310    return 1;
 311 }
 312
 313 /*
 314  * Open the JobMedia file for reading/writing
 315  */
 316 int bdb_open_jobmedia_file(B_DB *mdb)
 317 {
 318    char *dbf;
 319
 320    if (!mdb->jobmediafd) {
 321       dbf = make_filename(mdb, DB_JOBMEDIA_FILENAME);
 322       mdb->jobmediafd = fopen(dbf, "r+");
 323       if (!mdb->jobmediafd) {
 324          Mmsg2(&mdb->errmsg, "Error opening DB JobMedia file %s: ERR=%s\n",
 325             dbf, strerror(errno));
 326          Emsg0(M_FATAL, 0, mdb->errmsg);
 327          free_memory(dbf);
 328          return 0;
 329       }
 330       free_memory(dbf);
 331    }
 332    return 1;
 333 }
 334
 335
 336 /*
 337  * Open the Pools file for reading/writing
 338  */
 339 int bdb_open_pools_file(B_DB *mdb)
 340 {
 341    char *dbf;
 342
 343    if (!mdb->poolfd) {
 344       dbf = make_filename(mdb, DB_POOLS_FILENAME);
 345       mdb->poolfd = fopen(dbf, "r+");
 346       if (!mdb->poolfd) {
 347          Mmsg2(&mdb->errmsg, "Error opening DB Pools file %s: ERR=%s\n",
 348             dbf, strerror(errno));
 349          Emsg0(M_FATAL, 0, mdb->errmsg);
 350          free_memory(dbf);
 351          return 0;
 352       }
 353       Dmsg1(200, "Opened pool file %s\n", dbf);
 354       free_memory(dbf);
 355    }
 356    return 1;
 357 }
 358
 359 /*
 360  * Open the Client file for reading/writing
 361  */
 362 int bdb_open_client_file(B_DB *mdb)
 363 {
 364    char *dbf;
 365
 366    if (!mdb->clientfd) {
 367       dbf = make_filename(mdb, DB_CLIENT_FILENAME);
 368       mdb->clientfd = fopen(dbf, "r+");
 369       if (!mdb->clientfd) {
 370          Mmsg2(&mdb->errmsg, "Error opening DB Clients file %s: ERR=%s\n",
 371             dbf, strerror(errno));
 372          Emsg0(M_FATAL, 0, mdb->errmsg);
 373          free_memory(dbf);
 374          return 0;
 375       }
 376       free_memory(dbf);
 377    }
 378    return 1;
 379 }
 380
 381 /*
 382  * Open the FileSet file for reading/writing
 383  */
 384 int bdb_open_fileset_file(B_DB *mdb)
 385 {
 386    char *dbf;
 387
 388    if (!mdb->filesetfd) {
 389       dbf = make_filename(mdb, DB_CLIENT_FILENAME);
 390       mdb->filesetfd = fopen(dbf, "r+");
 391       if (!mdb->filesetfd) {
 392          Mmsg2(&mdb->errmsg, "Error opening DB FileSet file %s: ERR=%s\n",
 393             dbf, strerror(errno));
 394          Emsg0(M_FATAL, 0, mdb->errmsg);
 395          free_memory(dbf);
 396          return 0;
 397       }
 398       free_memory(dbf);
 399    }
 400    return 1;
 401 }
 402
 403
 404
 405 /*
 406  * Open the Media file for reading/writing
 407  */
 408 int bdb_open_media_file(B_DB *mdb)
 409 {
 410    char *dbf;
 411
 412    if (!mdb->mediafd) {
 413       dbf = make_filename(mdb, DB_MEDIA_FILENAME);
 414       mdb->mediafd = fopen(dbf, "r+");
 415       if (!mdb->mediafd) {
 416          Mmsg2(&mdb->errmsg, "Error opening DB Media file %s: ERR=%s\n",
 417             dbf, strerror(errno));
 418          free_memory(dbf);
 419          return 0;
 420       }
 421       free_memory(dbf);
 422    }
 423    return 1;
 424 }
 425
 426
 427 void _db_lock(char *file, int line, B_DB *mdb)
 428 {
 429    int errstat;
 430    if ((errstat=rwl_writelock(&mdb->lock)) != 0) {
 431       e_msg(file, line, M_ABORT, 0, "rwl_writelock failure. ERR=%s\n",
 432            strerror(errstat));
 433    }
 434 }
 435
 436 void _db_unlock(char *file, int line, B_DB *mdb)
 437 {
 438    int errstat;
 439    if ((errstat=rwl_writeunlock(&mdb->lock)) != 0) {
 440       e_msg(file, line, M_ABORT, 0, "rwl_writeunlock failure. ERR=%s\n",
 441            strerror(errstat));
 442    }
 443 }
 444
 445 /*
 446  * Start a transaction. This groups inserts and makes things
 447  *  much more efficient. Usually started when inserting
 448  *  file attributes.
 449  */
 450 void db_start_transaction(void *jcr, B_DB *mdb)
 451 {
 452 }
 453
 454 void db_end_transaction(void *jcr, B_DB *mdb)
 455 {
 456 }
 457
 458
 459 #endif /* HAVE_BACULA_DB */