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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2007 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 John Walker.
  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 specific to SQLite
  30  *
  31  *    Kern Sibbald, January 2002
  32  *
  33  *    Version $Id$
  34  */
  35
  36
  37
  38 /* The following is necessary so that we do not include
  39  * the dummy external definition of DB.
  40  */
  41 #define __SQL_C                       /* indicate that this is sql.c */
  42
  43 #include "bacula.h"
  44 #include "cats.h"
  45
  46 #if    HAVE_SQLITE || HAVE_SQLITE3
  47
  48 /* -----------------------------------------------------------------------
  49  *
  50  *    SQLite dependent defines and subroutines
  51  *
  52  * -----------------------------------------------------------------------
  53  */
  54
  55 /* List of open databases */
  56 static BQUEUE db_list = {&db_list, &db_list};
  57
  58 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  59
  60 int QueryDB(const char *file, int line, JCR *jcr, B_DB *db, char *select_cmd);
  61
  62
  63 /*
  64  * Retrieve database type
  65  */
  66 const char *
  67 db_get_type(void)
  68 {
  69    return "SQLite";
  70 }
  71
  72 /*
  73  * When using mult_db_connections = 1,
  74  * sqlite can be BUSY. We just need sleep a little in this case.
  75  */
  76
  77 #ifdef HAVE_SQLITE3
  78 static int my_busy_handler(void *arg, int calls)
  79 {
  80    bmicrosleep(0, 500);
  81    return 1;
  82 }
  83 #else
  84 static int my_busy_handler(void *arg, const char* p, int calls)
  85 {
  86    bmicrosleep(0, 500);
  87    return 1;
  88 }
  89 #endif
  90
  91
  92 /*
  93  * Initialize database data structure. In principal this should
  94  * never have errors, or it is really fatal.
  95  */
  96 B_DB *
  97 db_init_database(JCR *jcr, const char *db_name, const char *db_user, const char *db_password,
  98                  const char *db_address, int db_port, const char *db_socket,
  99                  int mult_db_connections)
 100 {
 101    B_DB *mdb;
 102
 103    P(mutex);                          /* lock DB queue */
 104    /* Look to see if DB already open */
 105    if (!mult_db_connections) {
 106       for (mdb=NULL; (mdb=(B_DB *)qnext(&db_list, &mdb->bq)); ) {
 107          if (bstrcmp(mdb->db_name, db_name) &&
 108              bstrcmp(mdb->db_address, db_address) &&
 109              mdb->db_port == db_port) {
 110             Dmsg2(300, "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    }
 117    Dmsg0(300, "db_open first time\n");
 118    mdb = (B_DB *) malloc(sizeof(B_DB));
 119    memset(mdb, 0, sizeof(B_DB));
 120    mdb->db_name = bstrdup(db_name);
 121    mdb->have_insert_id = TRUE;
 122    mdb->errmsg = get_pool_memory(PM_EMSG); /* get error message buffer */
 123    *mdb->errmsg = 0;
 124    mdb->cmd = get_pool_memory(PM_EMSG);    /* get command buffer */
 125    mdb->cached_path = get_pool_memory(PM_FNAME);
 126    mdb->cached_path_id = 0;
 127    mdb->ref_count = 1;
 128    mdb->fname = get_pool_memory(PM_FNAME);
 129    mdb->path = get_pool_memory(PM_FNAME);
 130    mdb->esc_name = get_pool_memory(PM_FNAME);
 131    mdb->esc_path = get_pool_memory(PM_FNAME);
 132    mdb->allow_transactions = mult_db_connections;
 133    qinsert(&db_list, &mdb->bq);            /* put db in list */
 134    V(mutex);
 135    return mdb;
 136 }
 137
 138 /*
 139  * Now actually open the database.  This can generate errors,
 140  * which are returned in the errmsg
 141  *
 142  * DO NOT close the database or free(mdb) here !!!!
 143  */
 144 int
 145 db_open_database(JCR *jcr, B_DB *mdb)
 146 {
 147    char *db_name;
 148    int len;
 149    struct stat statbuf;
 150    int errstat;
 151    int retry = 0;
 152
 153    P(mutex);
 154    if (mdb->connected) {
 155       V(mutex);
 156       return 1;
 157    }
 158    mdb->connected = FALSE;
 159
 160    if ((errstat=rwl_init(&mdb->lock)) != 0) {
 161       Mmsg1(&mdb->errmsg, _("Unable to initialize DB lock. ERR=%s\n"),
 162             strerror(errstat));
 163       V(mutex);
 164       return 0;
 165    }
 166
 167    /* open the database */
 168    len = strlen(working_directory) + strlen(mdb->db_name) + 5;
 169    db_name = (char *)malloc(len);
 170    strcpy(db_name, working_directory);
 171    strcat(db_name, "/");
 172    strcat(db_name, mdb->db_name);
 173    strcat(db_name, ".db");
 174    if (stat(db_name, &statbuf) != 0) {
 175       Mmsg1(&mdb->errmsg, _("Database %s does not exist, please create it.\n"),
 176          db_name);
 177       free(db_name);
 178       V(mutex);
 179       return 0;
 180    }
 181
 182    for (mdb->db=NULL; !mdb->db && retry++ < 10; ) {
 183 #ifdef HAVE_SQLITE3
 184       int stat = sqlite3_open(db_name, &mdb->db);
 185       if (stat != SQLITE_OK) {
 186          mdb->sqlite_errmsg = (char *)sqlite3_errmsg(mdb->db);
 187          sqlite3_close(mdb->db);
 188          mdb->db = NULL;
 189       } else {
 190          mdb->sqlite_errmsg = NULL;
 191       }
 192 #else
 193       mdb->db = sqlite_open(
 194            db_name,                      /* database name */
 195            644,                          /* mode */
 196            &mdb->sqlite_errmsg);         /* error message */
 197 #endif
 198
 199       Dmsg0(300, "sqlite_open\n");
 200       if (!mdb->db) {
 201          bmicrosleep(1, 0);
 202       }
 203    }
 204    if (mdb->db == NULL) {
 205       Mmsg2(&mdb->errmsg, _("Unable to open Database=%s. ERR=%s\n"),
 206          db_name, mdb->sqlite_errmsg ? mdb->sqlite_errmsg : _("unknown"));
 207       free(db_name);
 208       V(mutex);
 209       return 0;
 210    }
 211    mdb->connected = true;
 212    free(db_name);
 213
 214    /* set busy handler to wait when we use mult_db_connections = 1 */
 215 #ifdef HAVE_SQLITE3
 216    sqlite3_busy_handler(mdb->db, my_busy_handler, NULL);
 217 #else
 218    sqlite_busy_handler(mdb->db, my_busy_handler, NULL);
 219 #endif
 220
 221 #if  defined(HAVE_SQLITE3) && defined(SQLITE3_INIT_QUERY)
 222    db_sql_query(mdb, SQLITE3_INIT_QUERY, NULL, NULL);
 223 #endif
 224
 225    if (!check_tables_version(jcr, mdb)) {
 226       V(mutex);
 227       return 0;
 228    }
 229
 230
 231    V(mutex);
 232    return 1;
 233 }
 234
 235 void
 236 db_close_database(JCR *jcr, B_DB *mdb)
 237 {
 238    if (!mdb) {
 239       return;
 240    }
 241    db_end_transaction(jcr, mdb);
 242    P(mutex);
 243    sql_free_result(mdb);
 244    mdb->ref_count--;
 245    if (mdb->ref_count == 0) {
 246       qdchain(&mdb->bq);
 247       if (mdb->connected && mdb->db) {
 248          sqlite_close(mdb->db);
 249       }
 250       rwl_destroy(&mdb->lock);
 251       free_pool_memory(mdb->errmsg);
 252       free_pool_memory(mdb->cmd);
 253       free_pool_memory(mdb->cached_path);
 254       free_pool_memory(mdb->fname);
 255       free_pool_memory(mdb->path);
 256       free_pool_memory(mdb->esc_name);
 257       free_pool_memory(mdb->esc_path);
 258       if (mdb->db_name) {
 259          free(mdb->db_name);
 260       }
 261       free(mdb);
 262    }
 263    V(mutex);
 264 }
 265
 266 void db_thread_cleanup()
 267 {
 268 #ifdef HAVE_SQLITE3
 269    sqlite3_thread_cleanup();
 270 #endif
 271 }
 272
 273 /*
 274  * Return the next unique index (auto-increment) for
 275  * the given table.  Return 0 on error.
 276  */
 277 int db_next_index(JCR *jcr, B_DB *mdb, char *table, char *index)
 278 {
 279    strcpy(index, "NULL");
 280    return 1;
 281 }
 282
 283
 284 /*
 285  * Escape strings so that SQLite is happy
 286  *
 287  *   NOTE! len is the length of the old string. Your new
 288  *         string must be long enough (max 2*old+1) to hold
 289  *         the escaped output.
 290  */
 291 void
 292 db_escape_string(JCR *jcr, B_DB *db, char *snew, char *old, int len)
 293 {
 294    char *n, *o;
 295
 296    n = snew;
 297    o = old;
 298    while (len--) {
 299       switch (*o) {
 300       case '\'':
 301          *n++ = '\'';
 302          *n++ = '\'';
 303          o++;
 304          break;
 305       case 0:
 306          *n++ = '\\';
 307          *n++ = 0;
 308          o++;
 309          break;
 310       default:
 311          *n++ = *o++;
 312          break;
 313       }
 314    }
 315    *n = 0;
 316 }
 317
 318 struct rh_data {
 319    DB_RESULT_HANDLER *result_handler;
 320    void *ctx;
 321 };
 322
 323 /*
 324  * Convert SQLite's callback into Bacula DB callback
 325  */
 326 static int sqlite_result(void *arh_data, int num_fields, char **rows, char **col_names)
 327 {
 328    struct rh_data *rh_data = (struct rh_data *)arh_data;
 329
 330    if (rh_data->result_handler) {
 331       (*(rh_data->result_handler))(rh_data->ctx, num_fields, rows);
 332    }
 333    return 0;
 334 }
 335
 336 /*
 337  * Submit a general SQL command (cmd), and for each row returned,
 338  *  the sqlite_handler is called with the ctx.
 339  */
 340 int db_sql_query(B_DB *mdb, const char *query, DB_RESULT_HANDLER *result_handler, void *ctx)
 341 {
 342    struct rh_data rh_data;
 343    int stat;
 344
 345    db_lock(mdb);
 346    if (mdb->sqlite_errmsg) {
 347 #ifdef HAVE_SQLITE3
 348       sqlite3_free(mdb->sqlite_errmsg);
 349 #else
 350       actuallyfree(mdb->sqlite_errmsg);
 351 #endif
 352       mdb->sqlite_errmsg = NULL;
 353    }
 354    rh_data.result_handler = result_handler;
 355    rh_data.ctx = ctx;
 356    stat = sqlite_exec(mdb->db, query, sqlite_result, (void *)&rh_data, &mdb->sqlite_errmsg);
 357    if (stat != 0) {
 358       Mmsg(mdb->errmsg, _("Query failed: %s: ERR=%s\n"), query, sql_strerror(mdb));
 359       db_unlock(mdb);
 360       return 0;
 361    }
 362    db_unlock(mdb);
 363    return 1;
 364 }
 365
 366 /*
 367  * Submit a sqlite query and retrieve all the data
 368  */
 369 int my_sqlite_query(B_DB *mdb, const char *cmd)
 370 {
 371    int stat;
 372
 373    my_sqlite_free_table(mdb);
 374    if (mdb->sqlite_errmsg) {
 375 #ifdef HAVE_SQLITE3
 376       sqlite3_free(mdb->sqlite_errmsg);
 377 #else
 378       actuallyfree(mdb->sqlite_errmsg);
 379 #endif
 380       mdb->sqlite_errmsg = NULL;
 381    }
 382    stat = sqlite_get_table(mdb->db, (char *)cmd, &mdb->result, &mdb->nrow, &mdb->ncolumn,
 383             &mdb->sqlite_errmsg);
 384    mdb->row = 0;                      /* row fetched */
 385    return stat;
 386 }
 387
 388 /* Fetch one row at a time */
 389 SQL_ROW my_sqlite_fetch_row(B_DB *mdb)
 390 {
 391    if (mdb->row >= mdb->nrow) {
 392       return NULL;
 393    }
 394    mdb->row++;
 395    return &mdb->result[mdb->ncolumn * mdb->row];
 396 }
 397
 398 void my_sqlite_free_table(B_DB *mdb)
 399 {
 400    int i;
 401
 402    if (mdb->fields_defined) {
 403       for (i=0; i < sql_num_fields(mdb); i++) {
 404          free(mdb->fields[i]);
 405       }
 406       free(mdb->fields);
 407       mdb->fields_defined = false;
 408    }
 409    if (mdb->result) {
 410       sqlite_free_table(mdb->result);
 411       mdb->result = NULL;
 412    }
 413    mdb->nrow = mdb->ncolumn = 0;
 414 }
 415
 416 void my_sqlite_field_seek(B_DB *mdb, int field)
 417 {
 418    int i, j;
 419    if (mdb->result == NULL) {
 420       return;
 421    }
 422    /* On first call, set up the fields */
 423    if (!mdb->fields_defined && sql_num_fields(mdb) > 0) {
 424       mdb->fields = (SQL_FIELD **)malloc(sizeof(SQL_FIELD) * mdb->ncolumn);
 425       for (i=0; i < sql_num_fields(mdb); i++) {
 426          mdb->fields[i] = (SQL_FIELD *)malloc(sizeof(SQL_FIELD));
 427          mdb->fields[i]->name = mdb->result[i];
 428          mdb->fields[i]->length = cstrlen(mdb->fields[i]->name);
 429          mdb->fields[i]->max_length = mdb->fields[i]->length;
 430          for (j=1; j <= mdb->nrow; j++) {
 431             int len;
 432             if (mdb->result[i + mdb->ncolumn *j]) {
 433                len = (uint32_t)cstrlen(mdb->result[i + mdb->ncolumn * j]);
 434             } else {
 435                len = 0;
 436             }
 437             if (len > mdb->fields[i]->max_length) {
 438                mdb->fields[i]->max_length = len;
 439             }
 440          }
 441          mdb->fields[i]->type = 0;
 442          mdb->fields[i]->flags = 1;        /* not null */
 443       }
 444       mdb->fields_defined = TRUE;
 445    }
 446    if (field > sql_num_fields(mdb)) {
 447       field = sql_num_fields(mdb);
 448     }
 449     mdb->field = field;
 450
 451 }
 452
 453 SQL_FIELD *my_sqlite_fetch_field(B_DB *mdb)
 454 {
 455    return mdb->fields[mdb->field++];
 456 }
 457
 458 #ifdef HAVE_BATCH_FILE_INSERT
 459 char *my_sqlite_batch_lock_query = "BEGIN";
 460 char *my_sqlite_batch_unlock_query = "COMMIT";
 461 char *my_sqlite_batch_fill_path_query = "INSERT INTO Path (Path)          "
 462                                         " SELECT DISTINCT Path FROM batch "
 463                                         " EXCEPT SELECT Path FROM Path    ";
 464
 465 char *my_sqlite_batch_fill_filename_query = "INSERT INTO Filename (Name)       "
 466                                             " SELECT DISTINCT Name FROM batch  "
 467                                             " EXCEPT SELECT Name FROM Filename ";
 468 #endif /* HAVE_BATCH_FILE_INSERT */
 469
 470
 471 #endif /* HAVE_SQLITE */