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->have_insert_id = true;
 123    mdb->errmsg = get_pool_memory(PM_EMSG); /* get error message buffer */
 124    *mdb->errmsg = 0;
 125    mdb->cmd = get_pool_memory(PM_EMSG);    /* get command buffer */
 126    mdb->cached_path = get_pool_memory(PM_FNAME);
 127    mdb->cached_path_id = 0;
 128    mdb->ref_count = 1;
 129    mdb->fname = get_pool_memory(PM_FNAME);
 130    mdb->path = get_pool_memory(PM_FNAME);
 131    mdb->esc_name = get_pool_memory(PM_FNAME);
 132    mdb->esc_path = get_pool_memory(PM_FNAME);
 133    mdb->allow_transactions = mult_db_connections;
 134    qinsert(&db_list, &mdb->bq);            /* put db in list */
 135    V(mutex);
 136    return mdb;
 137 }
 138
 139 /*
 140  * Now actually open the database.  This can generate errors,
 141  * which are returned in the errmsg
 142  *
 143  * DO NOT close the database or free(mdb) here !!!!
 144  */
 145 int
 146 db_open_database(JCR *jcr, B_DB *mdb)
 147 {
 148    char *db_name;
 149    int len;
 150    struct stat statbuf;
 151    int errstat;
 152    int retry = 0;
 153
 154    P(mutex);
 155    if (mdb->connected) {
 156       V(mutex);
 157       return 1;
 158    }
 159    mdb->connected = FALSE;
 160
 161    if ((errstat=rwl_init(&mdb->lock)) != 0) {
 162       berrno be;
 163       Mmsg1(&mdb->errmsg, _("Unable to initialize DB lock. ERR=%s\n"),
 164             be.bstrerror(errstat));
 165       V(mutex);
 166       return 0;
 167    }
 168
 169    /* open the database */
 170    len = strlen(working_directory) + strlen(mdb->db_name) + 5;
 171    db_name = (char *)malloc(len);
 172    strcpy(db_name, working_directory);
 173    strcat(db_name, "/");
 174    strcat(db_name, mdb->db_name);
 175    strcat(db_name, ".db");
 176    if (stat(db_name, &statbuf) != 0) {
 177       Mmsg1(&mdb->errmsg, _("Database %s does not exist, please create it.\n"),
 178          db_name);
 179       free(db_name);
 180       V(mutex);
 181       return 0;
 182    }
 183
 184    for (mdb->db=NULL; !mdb->db && retry++ < 10; ) {
 185 #ifdef HAVE_SQLITE3
 186       int stat = sqlite3_open(db_name, &mdb->db);
 187       if (stat != SQLITE_OK) {
 188          mdb->sqlite_errmsg = (char *)sqlite3_errmsg(mdb->db);
 189          sqlite3_close(mdb->db);
 190          mdb->db = NULL;
 191       } else {
 192          mdb->sqlite_errmsg = NULL;
 193       }
 194 #else
 195       mdb->db = sqlite_open(
 196            db_name,                      /* database name */
 197            644,                          /* mode */
 198            &mdb->sqlite_errmsg);         /* error message */
 199 #endif
 200
 201       Dmsg0(300, "sqlite_open\n");
 202       if (!mdb->db) {
 203          bmicrosleep(1, 0);
 204       }
 205    }
 206    if (mdb->db == NULL) {
 207       Mmsg2(&mdb->errmsg, _("Unable to open Database=%s. ERR=%s\n"),
 208          db_name, mdb->sqlite_errmsg ? mdb->sqlite_errmsg : _("unknown"));
 209       free(db_name);
 210       V(mutex);
 211       return 0;
 212    }
 213    mdb->connected = true;
 214    free(db_name);
 215
 216    /* set busy handler to wait when we use mult_db_connections = 1 */
 217 #ifdef HAVE_SQLITE3
 218    sqlite3_busy_handler(mdb->db, my_busy_handler, NULL);
 219 #else
 220    sqlite_busy_handler(mdb->db, my_busy_handler, NULL);
 221 #endif
 222
 223 #if  defined(HAVE_SQLITE3) && defined(SQLITE3_INIT_QUERY)
 224    db_sql_query(mdb, SQLITE3_INIT_QUERY, NULL, NULL);
 225 #endif
 226
 227    if (!check_tables_version(jcr, mdb)) {
 228       V(mutex);
 229       return 0;
 230    }
 231
 232
 233    V(mutex);
 234    return 1;
 235 }
 236
 237 void
 238 db_close_database(JCR *jcr, B_DB *mdb)
 239 {
 240    if (!mdb) {
 241       return;
 242    }
 243    db_end_transaction(jcr, mdb);
 244    P(mutex);
 245    sql_free_result(mdb);
 246    mdb->ref_count--;
 247    if (mdb->ref_count == 0) {
 248       qdchain(&mdb->bq);
 249       if (mdb->connected && mdb->db) {
 250          sqlite_close(mdb->db);
 251       }
 252       rwl_destroy(&mdb->lock);
 253       free_pool_memory(mdb->errmsg);
 254       free_pool_memory(mdb->cmd);
 255       free_pool_memory(mdb->cached_path);
 256       free_pool_memory(mdb->fname);
 257       free_pool_memory(mdb->path);
 258       free_pool_memory(mdb->esc_name);
 259       free_pool_memory(mdb->esc_path);
 260       if (mdb->db_name) {
 261          free(mdb->db_name);
 262       }
 263       free(mdb);
 264    }
 265    V(mutex);
 266 }
 267
 268 void db_check_backend_thread_safe()
 269 {
 270 #ifdef HAVE_BATCH_FILE_INSERT
 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 }
 277
 278 void db_thread_cleanup()
 279 {
 280 #ifdef HAVE_SQLITE3
 281    sqlite3_thread_cleanup();
 282 #endif
 283 }
 284
 285 /*
 286  * Return the next unique index (auto-increment) for
 287  * the given table.  Return 0 on error.
 288  */
 289 int db_next_index(JCR *jcr, B_DB *mdb, char *table, char *index)
 290 {
 291    strcpy(index, "NULL");
 292    return 1;
 293 }
 294
 295
 296 /*
 297  * Escape strings so that SQLite is happy
 298  *
 299  *   NOTE! len is the length of the old string. Your new
 300  *         string must be long enough (max 2*old+1) to hold
 301  *         the escaped output.
 302  */
 303 void
 304 db_escape_string(JCR *jcr, B_DB *db, char *snew, char *old, int len)
 305 {
 306    char *n, *o;
 307
 308    n = snew;
 309    o = old;
 310    while (len--) {
 311       switch (*o) {
 312       case '\'':
 313          *n++ = '\'';
 314          *n++ = '\'';
 315          o++;
 316          break;
 317       case 0:
 318          *n++ = '\\';
 319          *n++ = 0;
 320          o++;
 321          break;
 322       default:
 323          *n++ = *o++;
 324          break;
 325       }
 326    }
 327    *n = 0;
 328 }
 329
 330 struct rh_data {
 331    DB_RESULT_HANDLER *result_handler;
 332    void *ctx;
 333 };
 334
 335 /*
 336  * Convert SQLite's callback into Bacula DB callback
 337  */
 338 static int sqlite_result(void *arh_data, int num_fields, char **rows, char **col_names)
 339 {
 340    struct rh_data *rh_data = (struct rh_data *)arh_data;
 341
 342    if (rh_data->result_handler) {
 343       (*(rh_data->result_handler))(rh_data->ctx, num_fields, rows);
 344    }
 345    return 0;
 346 }
 347
 348 /*
 349  * Submit a general SQL command (cmd), and for each row returned,
 350  *  the sqlite_handler is called with the ctx.
 351  */
 352 bool db_sql_query(B_DB *mdb, const char *query, DB_RESULT_HANDLER *result_handler, void *ctx)
 353 {
 354    struct rh_data rh_data;
 355    int stat;
 356
 357    db_lock(mdb);
 358    if (mdb->sqlite_errmsg) {
 359 #ifdef HAVE_SQLITE3
 360       sqlite3_free(mdb->sqlite_errmsg);
 361 #else
 362       actuallyfree(mdb->sqlite_errmsg);
 363 #endif
 364       mdb->sqlite_errmsg = NULL;
 365    }
 366    rh_data.result_handler = result_handler;
 367    rh_data.ctx = ctx;
 368    stat = sqlite_exec(mdb->db, query, sqlite_result, (void *)&rh_data, &mdb->sqlite_errmsg);
 369    if (stat != SQLITE_OK) {
 370       Mmsg(mdb->errmsg, _("Query failed: %s: ERR=%s\n"), query, sql_strerror(mdb));
 371       db_unlock(mdb);
 372       return false;
 373    }
 374    db_unlock(mdb);
 375    return true;
 376 }
 377
 378 /*
 379  * Submit a sqlite query and retrieve all the data
 380  */
 381 int my_sqlite_query(B_DB *mdb, const char *cmd)
 382 {
 383    int stat;
 384
 385    my_sqlite_free_table(mdb);
 386    if (mdb->sqlite_errmsg) {
 387 #ifdef HAVE_SQLITE3
 388       sqlite3_free(mdb->sqlite_errmsg);
 389 #else
 390       actuallyfree(mdb->sqlite_errmsg);
 391 #endif
 392       mdb->sqlite_errmsg = NULL;
 393    }
 394    stat = sqlite_get_table(mdb->db, (char *)cmd, &mdb->result, &mdb->nrow, &mdb->ncolumn,
 395             &mdb->sqlite_errmsg);
 396    mdb->row = 0;                      /* no row fetched yet */
 397    if (stat != 0) {                   /* something went wrong */
 398       mdb->nrow = mdb->ncolumn = 0;
 399    }
 400    return stat;
 401 }
 402
 403 /* Fetch one row at a time */
 404 SQL_ROW my_sqlite_fetch_row(B_DB *mdb)
 405 {
 406    if (!mdb->result || (mdb->row >= mdb->nrow)) {
 407       return NULL;
 408    }
 409    mdb->row++;
 410    return &mdb->result[mdb->ncolumn * mdb->row];
 411 }
 412
 413 void my_sqlite_free_table(B_DB *mdb)
 414 {
 415    int i;
 416
 417    if (mdb->fields_defined) {
 418       for (i=0; i < sql_num_fields(mdb); i++) {
 419          if (mdb->fields[i]) {
 420             free(mdb->fields[i]);
 421             mdb->fields[i] = NULL;
 422          }
 423       }
 424       if (mdb->fields) {
 425          free(mdb->fields);
 426          mdb->fields = NULL;
 427       }
 428       mdb->fields_defined = false;
 429    }
 430    if (mdb->result) {
 431       sqlite_free_table(mdb->result);
 432       mdb->result = NULL;
 433    }
 434    mdb->nrow = mdb->ncolumn = 0;
 435 }
 436
 437 void my_sqlite_field_seek(B_DB *mdb, int field)
 438 {
 439    int i, j;
 440    if (mdb->result == NULL) {
 441       mdb->field = 0;
 442       return;
 443    }
 444    /* On first call, set up the fields */
 445    if (!mdb->fields_defined && sql_num_fields(mdb) > 0) {
 446       mdb->fields = (SQL_FIELD **)malloc(sizeof(SQL_FIELD) * mdb->ncolumn);
 447       for (i=0; i < sql_num_fields(mdb); i++) {
 448          mdb->fields[i] = (SQL_FIELD *)malloc(sizeof(SQL_FIELD));
 449          mdb->fields[i]->name = mdb->result[i];
 450          mdb->fields[i]->length = cstrlen(mdb->fields[i]->name);
 451          mdb->fields[i]->max_length = mdb->fields[i]->length;
 452          for (j=1; j <= mdb->nrow; j++) {
 453             int len;
 454             if (mdb->result[i + mdb->ncolumn *j]) {
 455                len = (uint32_t)cstrlen(mdb->result[i + mdb->ncolumn * j]);
 456             } else {
 457                len = 0;
 458             }
 459             if (len > mdb->fields[i]->max_length) {
 460                mdb->fields[i]->max_length = len;
 461             }
 462          }
 463          mdb->fields[i]->type = 0;
 464          mdb->fields[i]->flags = 1;        /* not null */
 465       }
 466       mdb->fields_defined = true;
 467    }
 468    if (sql_num_fields(mdb) <= 0) {
 469       field = 0;
 470    } else if (field > sql_num_fields(mdb) - 1) {
 471       field = sql_num_fields(mdb) - 1;
 472     }
 473     mdb->field = field;
 474 }
 475
 476 SQL_FIELD *my_sqlite_fetch_field(B_DB *mdb)
 477 {
 478    if (mdb->fields_defined && mdb->field < sql_num_fields(mdb)) {
 479       return mdb->fields[mdb->field++];
 480    } else {
 481       mdb->field = 0;
 482       return NULL;
 483    }
 484 }
 485
 486 #ifdef HAVE_BATCH_FILE_INSERT
 487 const char *my_sqlite_batch_lock_query = "BEGIN";
 488 const char *my_sqlite_batch_unlock_query = "COMMIT";
 489
 490 const char *my_sqlite_batch_fill_path_query =
 491    "INSERT INTO Path (Path)"
 492    " SELECT DISTINCT Path FROM batch"
 493    " EXCEPT SELECT Path FROM Path";
 494
 495 const char *my_sqlite_batch_fill_filename_query =
 496    "INSERT INTO Filename (Name)"
 497    " SELECT DISTINCT Name FROM batch "
 498    " EXCEPT SELECT Name FROM Filename";
 499 #endif /* HAVE_BATCH_FILE_INSERT */
 500
 501
 502 #endif /* HAVE_SQLITE */