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, 2001, 2002 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(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    qinsert(&db_list, &mdb->bq);       /* put db in list */
 126    Dmsg0(200, "Done db_open_database()\n");
 127    mdb->cfd = -1;
 128    V(mutex);
 129    return mdb;
 130 }
 131
 132 /*
 133  * Now actually open the database.  This can generate errors,
 134  * which are returned in the errmsg
 135  */
 136 int
 137 db_open_database(B_DB *mdb)
 138 {
 139    char *dbf;
 140    int fd, badctl;
 141    int errstat;
 142    off_t filend;
 143
 144    Dmsg1(200, "db_open_database() %s\n", mdb->db_name);
 145
 146    P(mutex);
 147 #ifdef needed
 148    if ((errstat = pthread_mutex_init(&(mdb->mutex), NULL)) != 0) {
 149       Mmsg1(&mdb->errmsg, "Unable to initialize DB mutex. ERR=%s\n", strerror(errstat));
 150       V(mutex);
 151       return 0;
 152    }
 153    db_lock(mdb);                     /* test it once */
 154    db_unlock(mdb);
 155 #endif
 156
 157    if (rwl_init(&mdb->lock) != 0) {
 158       Mmsg1(&mdb->errmsg, "Unable to initialize DB lock. ERR=%s\n", strerror(errno));
 159       V(mutex);
 160       return 0;
 161    }
 162
 163    Dmsg0(200, "make_filename\n");
 164    dbf = make_filename(mdb, DB_CONTROL_FILENAME);
 165    mdb->cfd = open(dbf, O_CREAT|O_RDWR, 0600);
 166    free_memory(dbf);
 167    if (mdb->cfd < 0) {
 168       Mmsg2(&mdb->errmsg, "Unable to open Catalog DB control file %s: ERR=%s\n",
 169          dbf, strerror(errno));
 170       V(mutex);
 171       return 0;
 172    }
 173    Dmsg0(200, "DB open\n");
 174    /* See if the file was previously written */
 175    filend = lseek(mdb->cfd, 0, SEEK_END);
 176    if (filend == 0) {                 /* No, initialize everything */
 177       Dmsg0(200, "Init DB files\n");
 178       memset(&mdb->control, 0, sizeof(mdb->control));
 179       mdb->control.bdb_version = BDB_VERSION;
 180       bdb_write_control_file(mdb);
 181
 182       /* Create Jobs File */
 183       dbf = make_filename(mdb, DB_JOBS_FILENAME);
 184       fd = open(dbf, O_CREAT|O_RDWR, 0600);
 185       free_memory(dbf);
 186       close(fd);
 187
 188       /* Create Pools File */
 189       dbf = make_filename(mdb, DB_POOLS_FILENAME);
 190       fd = open(dbf, O_CREAT|O_RDWR, 0600);
 191       free_memory(dbf);
 192       close(fd);
 193
 194       /* Create Media File */
 195       dbf = make_filename(mdb, DB_MEDIA_FILENAME);
 196       fd = open(dbf, O_CREAT|O_RDWR, 0600);
 197       free_memory(dbf);
 198       close(fd);
 199
 200       /* Create JobMedia File */
 201       dbf = make_filename(mdb, DB_JOBMEDIA_FILENAME);
 202       fd = open(dbf, O_CREAT|O_RDWR, 0600);
 203       free_memory(dbf);
 204       close(fd);
 205
 206       /* Create Client File */
 207       dbf = make_filename(mdb, DB_CLIENT_FILENAME);
 208       fd = open(dbf, O_CREAT|O_RDWR, 0600);
 209       free_memory(dbf);
 210       close(fd);
 211
 212       /* Create FileSet File */
 213       dbf = make_filename(mdb, DB_FILESET_FILENAME);
 214       fd = open(dbf, O_CREAT|O_RDWR, 0600);
 215       free_memory(dbf);
 216       close(fd);
 217    }
 218
 219    Dmsg0(200, "Read control file\n");
 220    badctl = 0;
 221    lseek(mdb->cfd, 0, SEEK_SET);      /* seek to begining of control file */
 222    if (read(mdb->cfd, &mdb->control, sizeof(mdb->control)) != sizeof(mdb->control)) {
 223       Mmsg1(&mdb->errmsg, "Error reading catalog DB control file. ERR=%s\n", strerror(errno));
 224       badctl = 1;
 225    } else if (mdb->control.bdb_version != BDB_VERSION) {
 226       Mmsg2(&mdb->errmsg, "Error, catalog DB control file wrong version. \
 227 Wanted %d, got %d\n\
 228 Please reinitialize the working directory.\n",
 229          BDB_VERSION, mdb->control.bdb_version);
 230       badctl = 1;
 231    }
 232    if (badctl) {
 233       V(mutex);
 234       return 0;
 235    }
 236    V(mutex);
 237    return 1;
 238 }
 239
 240 void db_close_database(B_DB *mdb)
 241 {
 242    P(mutex);
 243    mdb->ref_count--;
 244    if (mdb->ref_count == 0) {
 245       qdchain(&mdb->bq);
 246       /*  close file descriptors */
 247       if (mdb->cfd >= 0) {
 248          close(mdb->cfd);
 249       }
 250       free(mdb->db_name);
 251       if (mdb->jobfd) {
 252          fclose(mdb->jobfd);
 253       }
 254       if (mdb->poolfd) {
 255          fclose(mdb->poolfd);
 256       }
 257       if (mdb->mediafd) {
 258          fclose(mdb->mediafd);
 259       }
 260       if (mdb->jobmediafd) {
 261          fclose(mdb->jobmediafd);
 262       }
 263       if (mdb->clientfd) {
 264          fclose(mdb->clientfd);
 265       }
 266       if (mdb->filesetfd) {
 267          fclose(mdb->filesetfd);
 268       }
 269 /*    pthread_mutex_destroy(&mdb->mutex); */
 270       rwl_destroy(&mdb->lock);
 271       free_pool_memory(mdb->errmsg);
 272       free_pool_memory(mdb->cmd);
 273       free(mdb);
 274    }
 275    V(mutex);
 276 }
 277
 278
 279 void db_escape_string(char *snew, char *old, int len)
 280 {
 281    strcpy(snew, old);
 282 }
 283
 284 char *db_strerror(B_DB *mdb)
 285 {
 286    return mdb->errmsg;
 287 }
 288
 289 int db_sql_query(B_DB *mdb, char *query, DB_RESULT_HANDLER *result_handler, void *ctx)
 290 {
 291    return 1;
 292 }
 293
 294 /*
 295  * Open the Jobs file for reading/writing
 296  */
 297 int bdb_open_jobs_file(B_DB *mdb)
 298 {
 299    char *dbf;
 300
 301    if (!mdb->jobfd) {
 302       dbf = make_filename(mdb, DB_JOBS_FILENAME);
 303       mdb->jobfd = fopen(dbf, "r+");
 304       if (!mdb->jobfd) {
 305          Mmsg2(&mdb->errmsg, "Error opening DB Jobs file %s: ERR=%s\n",
 306             dbf, strerror(errno));
 307          Emsg0(M_FATAL, 0, mdb->errmsg);
 308          free_memory(dbf);
 309          return 0;
 310       }
 311       free_memory(dbf);
 312    }
 313    return 1;
 314 }
 315
 316 /*
 317  * Open the JobMedia file for reading/writing
 318  */
 319 int bdb_open_jobmedia_file(B_DB *mdb)
 320 {
 321    char *dbf;
 322
 323    if (!mdb->jobmediafd) {
 324       dbf = make_filename(mdb, DB_JOBMEDIA_FILENAME);
 325       mdb->jobmediafd = fopen(dbf, "r+");
 326       if (!mdb->jobmediafd) {
 327          Mmsg2(&mdb->errmsg, "Error opening DB JobMedia file %s: ERR=%s\n",
 328             dbf, strerror(errno));
 329          Emsg0(M_FATAL, 0, mdb->errmsg);
 330          free_memory(dbf);
 331          return 0;
 332       }
 333       free_memory(dbf);
 334    }
 335    return 1;
 336 }
 337
 338
 339 /*
 340  * Open the Pools file for reading/writing
 341  */
 342 int bdb_open_pools_file(B_DB *mdb)
 343 {
 344    char *dbf;
 345
 346    if (!mdb->poolfd) {
 347       dbf = make_filename(mdb, DB_POOLS_FILENAME);
 348       mdb->poolfd = fopen(dbf, "r+");
 349       if (!mdb->poolfd) {
 350          Mmsg2(&mdb->errmsg, "Error opening DB Pools file %s: ERR=%s\n",
 351             dbf, strerror(errno));
 352          Emsg0(M_FATAL, 0, mdb->errmsg);
 353          free_memory(dbf);
 354          return 0;
 355       }
 356       Dmsg1(200, "Opened pool file %s\n", dbf);
 357       free_memory(dbf);
 358    }
 359    return 1;
 360 }
 361
 362 /*
 363  * Open the Client file for reading/writing
 364  */
 365 int bdb_open_client_file(B_DB *mdb)
 366 {
 367    char *dbf;
 368
 369    if (!mdb->clientfd) {
 370       dbf = make_filename(mdb, DB_CLIENT_FILENAME);
 371       mdb->clientfd = fopen(dbf, "r+");
 372       if (!mdb->clientfd) {
 373          Mmsg2(&mdb->errmsg, "Error opening DB Clients file %s: ERR=%s\n",
 374             dbf, strerror(errno));
 375          Emsg0(M_FATAL, 0, mdb->errmsg);
 376          free_memory(dbf);
 377          return 0;
 378       }
 379       free_memory(dbf);
 380    }
 381    return 1;
 382 }
 383
 384 /*
 385  * Open the FileSet file for reading/writing
 386  */
 387 int bdb_open_fileset_file(B_DB *mdb)
 388 {
 389    char *dbf;
 390
 391    if (!mdb->filesetfd) {
 392       dbf = make_filename(mdb, DB_CLIENT_FILENAME);
 393       mdb->filesetfd = fopen(dbf, "r+");
 394       if (!mdb->filesetfd) {
 395          Mmsg2(&mdb->errmsg, "Error opening DB FileSet file %s: ERR=%s\n",
 396             dbf, strerror(errno));
 397          Emsg0(M_FATAL, 0, mdb->errmsg);
 398          free_memory(dbf);
 399          return 0;
 400       }
 401       free_memory(dbf);
 402    }
 403    return 1;
 404 }
 405
 406
 407
 408 /*
 409  * Open the Media file for reading/writing
 410  */
 411 int bdb_open_media_file(B_DB *mdb)
 412 {
 413    char *dbf;
 414
 415    if (!mdb->mediafd) {
 416       dbf = make_filename(mdb, DB_MEDIA_FILENAME);
 417       mdb->mediafd = fopen(dbf, "r+");
 418       if (!mdb->mediafd) {
 419          Mmsg2(&mdb->errmsg, "Error opening DB Media file %s: ERR=%s\n",
 420             dbf, strerror(errno));
 421          free_memory(dbf);
 422          return 0;
 423       }
 424       free_memory(dbf);
 425    }
 426    return 1;
 427 }
 428
 429
 430 void _db_lock(char *file, int line, B_DB *mdb)
 431 {
 432    int errstat;
 433    if ((errstat=rwl_writelock(&mdb->lock)) != 0) {
 434       e_msg(file, line, M_ABORT, 0, "rwl_writelock failure. ERR=%s\n",
 435            strerror(errstat));
 436    }
 437 }
 438
 439 void _db_unlock(char *file, int line, B_DB *mdb)
 440 {
 441    int errstat;
 442    if ((errstat=rwl_writeunlock(&mdb->lock)) != 0) {
 443       e_msg(file, line, M_ABORT, 0, "rwl_writeunlock failure. ERR=%s\n",
 444            strerror(errstat));
 445    }
 446 }
 447
 448 #endif /* HAVE_BACULA_DB */