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

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