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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2010 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 specific to SQLite
  30  *
  31  *    Kern Sibbald, January 2002
  32  *
  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 #if    HAVE_SQLITE || HAVE_SQLITE3
  46
  47 /* -----------------------------------------------------------------------
  48  *
  49  *    SQLite dependent defines and subroutines
  50  *
  51  * -----------------------------------------------------------------------
  52  */
  53
  54 /* List of open databases */
  55 static dlist *db_list = NULL;
  56
  57 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  58
  59 /*
  60  * Retrieve database type
  61  */
  62 const char *
  63 db_get_type(void)
  64 {
  65 #ifdef HAVE_SQLITE3
  66    return "SQLite3";
  67 #else
  68    return "SQLite";
  69 #endif
  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 = NULL;
 102
 103    P(mutex);                          /* lock DB queue */
 104    if (db_list == NULL) {
 105       db_list = New(dlist(mdb, &mdb->link));
 106    }
 107    /* Look to see if DB already open */
 108    if (!mult_db_connections) {
 109       foreach_dlist(mdb, db_list) {
 110          if (bstrcmp(mdb->db_name, db_name) &&
 111              bstrcmp(mdb->db_address, db_address) &&
 112              mdb->db_port == db_port) {
 113             Dmsg2(300, "DB REopen %d %s\n", mdb->ref_count, db_name);
 114             mdb->ref_count++;
 115             V(mutex);
 116             return mdb;                  /* already open */
 117          }
 118       }
 119    }
 120    Dmsg0(300, "db_open first time\n");
 121    mdb = (B_DB *)malloc(sizeof(B_DB));
 122    memset(mdb, 0, sizeof(B_DB));
 123    mdb->db_name = bstrdup(db_name);
 124    mdb->errmsg = get_pool_memory(PM_EMSG); /* get error message buffer */
 125    *mdb->errmsg = 0;
 126    mdb->cmd = get_pool_memory(PM_EMSG);    /* get command buffer */
 127    mdb->cached_path = get_pool_memory(PM_FNAME);
 128    mdb->cached_path_id = 0;
 129    mdb->ref_count = 1;
 130    mdb->fname = get_pool_memory(PM_FNAME);
 131    mdb->path = get_pool_memory(PM_FNAME);
 132    mdb->esc_name = get_pool_memory(PM_FNAME);
 133    mdb->esc_path = get_pool_memory(PM_FNAME);
 134    mdb->allow_transactions = mult_db_connections;
 135    db_list->append(mdb);
 136    V(mutex);
 137    return mdb;
 138 }
 139
 140 /*
 141  * Now actually open the database.  This can generate errors,
 142  * which are returned in the errmsg
 143  *
 144  * DO NOT close the database or free(mdb) here !!!!
 145  */
 146 int
 147 db_open_database(JCR *jcr, B_DB *mdb)
 148 {
 149    char *db_name;
 150    int len;
 151    struct stat statbuf;
 152    int errstat;
 153    int retry = 0;
 154
 155    P(mutex);
 156    if (mdb->connected) {
 157       V(mutex);
 158       return 1;
 159    }
 160    mdb->connected = FALSE;
 161
 162    if ((errstat=rwl_init(&mdb->lock)) != 0) {
 163       berrno be;
 164       Mmsg1(&mdb->errmsg, _("Unable to initialize DB lock. ERR=%s\n"),
 165             be.bstrerror(errstat));
 166       V(mutex);
 167       return 0;
 168    }
 169
 170    /* open the database */
 171    len = strlen(working_directory) + strlen(mdb->db_name) + 5;
 172    db_name = (char *)malloc(len);
 173    strcpy(db_name, working_directory);
 174    strcat(db_name, "/");
 175    strcat(db_name, mdb->db_name);
 176    strcat(db_name, ".db");
 177    if (stat(db_name, &statbuf) != 0) {
 178       Mmsg1(&mdb->errmsg, _("Database %s does not exist, please create it.\n"),
 179          db_name);
 180       free(db_name);
 181       V(mutex);
 182       return 0;
 183    }
 184
 185    for (mdb->db=NULL; !mdb->db && retry++ < 10; ) {
 186 #ifdef HAVE_SQLITE3
 187       int stat = sqlite3_open(db_name, &mdb->db);
 188       if (stat != SQLITE_OK) {
 189          mdb->sqlite_errmsg = (char *)sqlite3_errmsg(mdb->db);
 190          sqlite3_close(mdb->db);
 191          mdb->db = NULL;
 192       } else {
 193          mdb->sqlite_errmsg = NULL;
 194       }
 195 #else
 196       mdb->db = sqlite_open(
 197            db_name,                      /* database name */
 198            644,                          /* mode */
 199            &mdb->sqlite_errmsg);         /* error message */
 200 #endif
 201
 202       Dmsg0(300, "sqlite_open\n");
 203       if (!mdb->db) {
 204          bmicrosleep(1, 0);
 205       }
 206    }
 207    if (mdb->db == NULL) {
 208       Mmsg2(&mdb->errmsg, _("Unable to open Database=%s. ERR=%s\n"),
 209          db_name, mdb->sqlite_errmsg ? mdb->sqlite_errmsg : _("unknown"));
 210       free(db_name);
 211       V(mutex);
 212       return 0;
 213    }
 214    mdb->connected = true;
 215    free(db_name);
 216
 217    /* set busy handler to wait when we use mult_db_connections = 1 */
 218 #ifdef HAVE_SQLITE3
 219    sqlite3_busy_handler(mdb->db, my_busy_handler, NULL);
 220 #else
 221    sqlite_busy_handler(mdb->db, my_busy_handler, NULL);
 222 #endif
 223
 224 #if  defined(HAVE_SQLITE3) && defined(SQLITE3_INIT_QUERY)
 225    db_sql_query(mdb, SQLITE3_INIT_QUERY, NULL, NULL);
 226 #endif
 227
 228    if (!check_tables_version(jcr, mdb)) {
 229       V(mutex);
 230       return 0;
 231    }
 232
 233
 234    V(mutex);
 235    return 1;
 236 }
 237
 238 void
 239 db_close_database(JCR *jcr, B_DB *mdb)
 240 {
 241    if (!mdb) {
 242       return;
 243    }
 244    db_end_transaction(jcr, mdb);
 245    P(mutex);
 246    sql_free_result(mdb);
 247    mdb->ref_count--;
 248    if (mdb->ref_count == 0) {
 249       db_list->remove(mdb);
 250       if (mdb->connected && mdb->db) {
 251          sqlite_close(mdb->db);
 252       }
 253       rwl_destroy(&mdb->lock);
 254       free_pool_memory(mdb->errmsg);
 255       free_pool_memory(mdb->cmd);
 256       free_pool_memory(mdb->cached_path);
 257       free_pool_memory(mdb->fname);
 258       free_pool_memory(mdb->path);
 259       free_pool_memory(mdb->esc_name);
 260       free_pool_memory(mdb->esc_path);
 261       if (mdb->db_name) {
 262          free(mdb->db_name);
 263       }
 264       free(mdb);
 265       if (db_list->size() == 0) {
 266          delete db_list;
 267          db_list = NULL;
 268       }
 269    }
 270    V(mutex);
 271 }
 272
 273 void db_check_backend_thread_safe()
 274 {
 275 #ifdef HAVE_BATCH_FILE_INSERT
 276 # ifdef HAVE_SQLITE3_THREADSAFE
 277    if (!sqlite3_threadsafe()) {
 278       Emsg0(M_ABORT, 0, _("SQLite3 client library must be thread-safe "
 279                           "when using BatchMode.\n"));
 280    }
 281 # endif
 282 #endif
 283 }
 284
 285 void db_thread_cleanup()
 286 {
 287 #ifdef HAVE_SQLITE3
 288    sqlite3_thread_cleanup();
 289 #endif
 290 }
 291
 292 /*
 293  * Return the next unique index (auto-increment) for
 294  * the given table.  Return 0 on error.
 295  */
 296 int db_next_index(JCR *jcr, B_DB *mdb, char *table, char *index)
 297 {
 298    strcpy(index, "NULL");
 299    return 1;
 300 }
 301
 302
 303 /*
 304  * Escape strings so that SQLite is happy
 305  *
 306  *   NOTE! len is the length of the old string. Your new
 307  *         string must be long enough (max 2*old+1) to hold
 308  *         the escaped output.
 309  */
 310 void
 311 db_escape_string(JCR *jcr, B_DB *db, char *snew, char *old, int len)
 312 {
 313    char *n, *o;
 314
 315    n = snew;
 316    o = old;
 317    while (len--) {
 318       switch (*o) {
 319       case '\'':
 320          *n++ = '\'';
 321          *n++ = '\'';
 322          o++;
 323          break;
 324       case 0:
 325          *n++ = '\\';
 326          *n++ = 0;
 327          o++;
 328          break;
 329       default:
 330          *n++ = *o++;
 331          break;
 332       }
 333    }
 334    *n = 0;
 335 }
 336
 337 struct rh_data {
 338    DB_RESULT_HANDLER *result_handler;
 339    void *ctx;
 340 };
 341
 342 /*
 343  * Convert SQLite's callback into Bacula DB callback
 344  */
 345 static int sqlite_result(void *arh_data, int num_fields, char **rows, char **col_names)
 346 {
 347    struct rh_data *rh_data = (struct rh_data *)arh_data;
 348
 349    if (rh_data->result_handler) {
 350       (*(rh_data->result_handler))(rh_data->ctx, num_fields, rows);
 351    }
 352    return 0;
 353 }
 354
 355 /*
 356  * Submit a general SQL command (cmd), and for each row returned,
 357  *  the sqlite_handler is called with the ctx.
 358  */
 359 bool db_sql_query(B_DB *mdb, const char *query, DB_RESULT_HANDLER *result_handler, void *ctx)
 360 {
 361    struct rh_data rh_data;
 362    int stat;
 363
 364    db_lock(mdb);
 365    if (mdb->sqlite_errmsg) {
 366 #ifdef HAVE_SQLITE3
 367       sqlite3_free(mdb->sqlite_errmsg);
 368 #else
 369       actuallyfree(mdb->sqlite_errmsg);
 370 #endif
 371       mdb->sqlite_errmsg = NULL;
 372    }
 373    rh_data.result_handler = result_handler;
 374    rh_data.ctx = ctx;
 375    stat = sqlite_exec(mdb->db, query, sqlite_result, (void *)&rh_data, &mdb->sqlite_errmsg);
 376    if (stat != SQLITE_OK) {
 377       Mmsg(mdb->errmsg, _("Query failed: %s: ERR=%s\n"), query, sql_strerror(mdb));
 378       db_unlock(mdb);
 379       return false;
 380    }
 381    db_unlock(mdb);
 382    return true;
 383 }
 384
 385 /*
 386  * Submit a sqlite query and retrieve all the data
 387  */
 388 int my_sqlite_query(B_DB *mdb, const char *cmd)
 389 {
 390    int stat;
 391
 392    my_sqlite_free_table(mdb);
 393    if (mdb->sqlite_errmsg) {
 394 #ifdef HAVE_SQLITE3
 395       sqlite3_free(mdb->sqlite_errmsg);
 396 #else
 397       actuallyfree(mdb->sqlite_errmsg);
 398 #endif
 399       mdb->sqlite_errmsg = NULL;
 400    }
 401    stat = sqlite_get_table(mdb->db, (char *)cmd, &mdb->result, &mdb->nrow, &mdb->ncolumn,
 402             &mdb->sqlite_errmsg);
 403    mdb->row = 0;                      /* no row fetched yet */
 404    if (stat != 0) {                   /* something went wrong */
 405       mdb->nrow = mdb->ncolumn = 0;
 406    }
 407    return stat;
 408 }
 409
 410 /* Fetch one row at a time */
 411 SQL_ROW my_sqlite_fetch_row(B_DB *mdb)
 412 {
 413    if (!mdb->result || (mdb->row >= mdb->nrow)) {
 414       return NULL;
 415    }
 416    mdb->row++;
 417    return &mdb->result[mdb->ncolumn * mdb->row];
 418 }
 419
 420 void my_sqlite_free_table(B_DB *mdb)
 421 {
 422    int i;
 423
 424    if (mdb->fields_defined) {
 425       for (i=0; i < sql_num_fields(mdb); i++) {
 426          if (mdb->fields[i]) {
 427             free(mdb->fields[i]);
 428             mdb->fields[i] = NULL;
 429          }
 430       }
 431       if (mdb->fields) {
 432          free(mdb->fields);
 433          mdb->fields = NULL;
 434       }
 435       mdb->fields_defined = false;
 436    }
 437    if (mdb->result) {
 438       sqlite_free_table(mdb->result);
 439       mdb->result = NULL;
 440    }
 441    mdb->nrow = mdb->ncolumn = 0;
 442 }
 443
 444 void my_sqlite_field_seek(B_DB *mdb, int field)
 445 {
 446    int i, j;
 447    if (mdb->result == NULL) {
 448       mdb->field = 0;
 449       return;
 450    }
 451    /* On first call, set up the fields */
 452    if (!mdb->fields_defined && sql_num_fields(mdb) > 0) {
 453       mdb->fields = (SQL_FIELD **)malloc(sizeof(SQL_FIELD) * mdb->ncolumn);
 454       for (i=0; i < sql_num_fields(mdb); i++) {
 455          mdb->fields[i] = (SQL_FIELD *)malloc(sizeof(SQL_FIELD));
 456          /* ***FIXME***  it seems to me that this is wrong
 457           *   fields has lots of items
 458           */
 459          if (mdb->result[i] == NULL) {
 460             mdb->fields_defined = false;
 461             free(mdb->fields);
 462             mdb->fields = NULL;
 463             mdb->field = 0;
 464             return;
 465          }
 466          mdb->fields[i]->name = mdb->result[i];
 467          mdb->fields[i]->length = cstrlen(mdb->fields[i]->name);
 468          mdb->fields[i]->max_length = mdb->fields[i]->length;
 469          for (j=1; j <= mdb->nrow; j++) {
 470             int len;
 471             if (mdb->result[i + mdb->ncolumn *j]) {
 472                len = (uint32_t)cstrlen(mdb->result[i + mdb->ncolumn * j]);
 473             } else {
 474                len = 0;
 475             }
 476             if (len > mdb->fields[i]->max_length) {
 477                mdb->fields[i]->max_length = len;
 478             }
 479          }
 480          mdb->fields[i]->type = 0;
 481          mdb->fields[i]->flags = 1;        /* not null */
 482       }
 483       mdb->fields_defined = true;
 484    }
 485    if (sql_num_fields(mdb) <= 0) {
 486       field = 0;
 487    } else if (field > sql_num_fields(mdb) - 1) {
 488       field = sql_num_fields(mdb) - 1;
 489     }
 490     mdb->field = field;
 491 }
 492
 493 SQL_FIELD *my_sqlite_fetch_field(B_DB *mdb)
 494 {
 495    if (mdb->fields_defined && mdb->field < sql_num_fields(mdb)) {
 496       return mdb->fields[mdb->field++];
 497    } else {
 498       mdb->field = 0;
 499       return NULL;
 500    }
 501 }
 502
 503 int my_sqlite_insert_autokey_record(B_DB *mdb, const char *query, const char *table_name)
 504 {
 505    /*
 506     * First execute the insert query and then retrieve the currval.
 507     */
 508    if (my_sqlite_query(mdb, query)) {
 509       return 0;
 510    }
 511
 512    mdb->num_rows = sql_affected_rows(mdb);
 513    if (mdb->num_rows != 1) {
 514       return 0;
 515    }
 516
 517    mdb->changes++;
 518
 519 #ifdef HAVE_SQLITE3
 520    return sqlite3_last_insert_rowid(mdb->db);
 521 #else
 522    return sqlite_last_insert_rowid(mdb->db);
 523 #endif
 524 }
 525
 526 #ifdef HAVE_BATCH_FILE_INSERT
 527 const char *my_sqlite_batch_lock_query = "BEGIN";
 528 const char *my_sqlite_batch_unlock_query = "COMMIT";
 529
 530 const char *my_sqlite_batch_fill_path_query =
 531    "INSERT INTO Path (Path)"
 532    " SELECT DISTINCT Path FROM batch"
 533    " EXCEPT SELECT Path FROM Path";
 534
 535 const char *my_sqlite_batch_fill_filename_query =
 536    "INSERT INTO Filename (Name)"
 537    " SELECT DISTINCT Name FROM batch "
 538    " EXCEPT SELECT Name FROM Filename";
 539 #endif /* HAVE_BATCH_FILE_INSERT */
 540
 541
 542 #endif /* HAVE_SQLITE */