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 plus additions
  11    that are listed 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
 152    P(mutex);
 153    if (mdb->connected) {
 154       V(mutex);
 155       return 1;
 156    }
 157    mdb->connected = FALSE;
 158
 159    if ((errstat=rwl_init(&mdb->lock)) != 0) {
 160       Mmsg1(&mdb->errmsg, _("Unable to initialize DB lock. ERR=%s\n"),
 161             strerror(errstat));
 162       V(mutex);
 163       return 0;
 164    }
 165
 166    /* open the database */
 167    len = strlen(working_directory) + strlen(mdb->db_name) + 5;
 168    db_name = (char *)malloc(len);
 169    strcpy(db_name, working_directory);
 170    strcat(db_name, "/");
 171    strcat(db_name, mdb->db_name);
 172    strcat(db_name, ".db");
 173    if (stat(db_name, &statbuf) != 0) {
 174       Mmsg1(&mdb->errmsg, _("Database %s does not exist, please create it.\n"),
 175          db_name);
 176       free(db_name);
 177       V(mutex);
 178       return 0;
 179    }
 180
 181 #ifdef HAVE_SQLITE3
 182    int stat = sqlite3_open(db_name, &mdb->db);
 183    if (stat != SQLITE_OK) {
 184       mdb->sqlite_errmsg = (char *)sqlite3_errmsg(mdb->db);
 185       sqlite3_close(mdb->db);
 186       mdb->db = NULL;
 187    } else {
 188       mdb->sqlite_errmsg = NULL;
 189    }
 190 #ifdef SQLITE3_INIT_QUERY
 191    db_sql_query(mdb, SQLITE3_INIT_QUERY, NULL, NULL);
 192 #endif
 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
 203    if (mdb->db == NULL) {
 204       Mmsg2(&mdb->errmsg, _("Unable to open Database=%s. ERR=%s\n"),
 205          db_name, mdb->sqlite_errmsg ? mdb->sqlite_errmsg : _("unknown"));
 206       free(db_name);
 207       V(mutex);
 208       return 0;
 209    }
 210    mdb->connected = true;
 211    free(db_name);
 212    if (!check_tables_version(jcr, mdb)) {
 213       V(mutex);
 214       return 0;
 215    }
 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    V(mutex);
 225    return 1;
 226 }
 227
 228 void
 229 db_close_database(JCR *jcr, B_DB *mdb)
 230 {
 231    if (!mdb) {
 232       return;
 233    }
 234    db_end_transaction(jcr, mdb);
 235    P(mutex);
 236    sql_free_result(mdb);
 237    mdb->ref_count--;
 238    if (mdb->ref_count == 0) {
 239       qdchain(&mdb->bq);
 240       if (mdb->connected && mdb->db) {
 241          sqlite_close(mdb->db);
 242       }
 243       rwl_destroy(&mdb->lock);
 244       free_pool_memory(mdb->errmsg);
 245       free_pool_memory(mdb->cmd);
 246       free_pool_memory(mdb->cached_path);
 247       free_pool_memory(mdb->fname);
 248       free_pool_memory(mdb->path);
 249       free_pool_memory(mdb->esc_name);
 250       free_pool_memory(mdb->esc_path);
 251       if (mdb->db_name) {
 252          free(mdb->db_name);
 253       }
 254       free(mdb);
 255    }
 256    V(mutex);
 257 }
 258
 259 void db_thread_cleanup()
 260 {
 261 #ifdef HAVE_SQLITE3
 262    sqlite3_thread_cleanup();
 263 #endif
 264 }
 265
 266 /*
 267  * Return the next unique index (auto-increment) for
 268  * the given table.  Return 0 on error.
 269  */
 270 int db_next_index(JCR *jcr, B_DB *mdb, char *table, char *index)
 271 {
 272    strcpy(index, "NULL");
 273    return 1;
 274 }
 275
 276
 277 /*
 278  * Escape strings so that SQLite is happy
 279  *
 280  *   NOTE! len is the length of the old string. Your new
 281  *         string must be long enough (max 2*old+1) to hold
 282  *         the escaped output.
 283  */
 284 void
 285 db_escape_string(char *snew, char *old, int len)
 286 {
 287    char *n, *o;
 288
 289    n = snew;
 290    o = old;
 291    while (len--) {
 292       switch (*o) {
 293       case '\'':
 294          *n++ = '\'';
 295          *n++ = '\'';
 296          o++;
 297          break;
 298       case 0:
 299          *n++ = '\\';
 300          *n++ = 0;
 301          o++;
 302          break;
 303       default:
 304          *n++ = *o++;
 305          break;
 306       }
 307    }
 308    *n = 0;
 309 }
 310
 311 struct rh_data {
 312    DB_RESULT_HANDLER *result_handler;
 313    void *ctx;
 314 };
 315
 316 /*
 317  * Convert SQLite's callback into Bacula DB callback
 318  */
 319 static int sqlite_result(void *arh_data, int num_fields, char **rows, char **col_names)
 320 {
 321    struct rh_data *rh_data = (struct rh_data *)arh_data;
 322
 323    if (rh_data->result_handler) {
 324       (*(rh_data->result_handler))(rh_data->ctx, num_fields, rows);
 325    }
 326    return 0;
 327 }
 328
 329 /*
 330  * Submit a general SQL command (cmd), and for each row returned,
 331  *  the sqlite_handler is called with the ctx.
 332  */
 333 int db_sql_query(B_DB *mdb, const char *query, DB_RESULT_HANDLER *result_handler, void *ctx)
 334 {
 335    struct rh_data rh_data;
 336    int stat;
 337
 338    db_lock(mdb);
 339    if (mdb->sqlite_errmsg) {
 340 #ifdef HAVE_SQLITE3
 341       sqlite3_free(mdb->sqlite_errmsg);
 342 #else
 343       actuallyfree(mdb->sqlite_errmsg);
 344 #endif
 345       mdb->sqlite_errmsg = NULL;
 346    }
 347    rh_data.result_handler = result_handler;
 348    rh_data.ctx = ctx;
 349    stat = sqlite_exec(mdb->db, query, sqlite_result, (void *)&rh_data, &mdb->sqlite_errmsg);
 350    if (stat != 0) {
 351       Mmsg(mdb->errmsg, _("Query failed: %s: ERR=%s\n"), query, sql_strerror(mdb));
 352       db_unlock(mdb);
 353       return 0;
 354    }
 355    db_unlock(mdb);
 356    return 1;
 357 }
 358
 359 /*
 360  * Submit a sqlite query and retrieve all the data
 361  */
 362 int my_sqlite_query(B_DB *mdb, const char *cmd)
 363 {
 364    int stat;
 365
 366    my_sqlite_free_table(mdb);
 367    if (mdb->sqlite_errmsg) {
 368 #ifdef HAVE_SQLITE3
 369       sqlite3_free(mdb->sqlite_errmsg);
 370 #else
 371       actuallyfree(mdb->sqlite_errmsg);
 372 #endif
 373       mdb->sqlite_errmsg = NULL;
 374    }
 375    stat = sqlite_get_table(mdb->db, (char *)cmd, &mdb->result, &mdb->nrow, &mdb->ncolumn,
 376             &mdb->sqlite_errmsg);
 377    mdb->row = 0;                      /* row fetched */
 378    return stat;
 379 }
 380
 381 /* Fetch one row at a time */
 382 SQL_ROW my_sqlite_fetch_row(B_DB *mdb)
 383 {
 384    if (mdb->row >= mdb->nrow) {
 385       return NULL;
 386    }
 387    mdb->row++;
 388    return &mdb->result[mdb->ncolumn * mdb->row];
 389 }
 390
 391 void my_sqlite_free_table(B_DB *mdb)
 392 {
 393    int i;
 394
 395    if (mdb->fields_defined) {
 396       for (i=0; i < sql_num_fields(mdb); i++) {
 397          free(mdb->fields[i]);
 398       }
 399       free(mdb->fields);
 400       mdb->fields_defined = false;
 401    }
 402    if (mdb->result) {
 403       sqlite_free_table(mdb->result);
 404       mdb->result = NULL;
 405    }
 406    mdb->nrow = mdb->ncolumn = 0;
 407 }
 408
 409 void my_sqlite_field_seek(B_DB *mdb, int field)
 410 {
 411    int i, j;
 412    if (mdb->result == NULL) {
 413       return;
 414    }
 415    /* On first call, set up the fields */
 416    if (!mdb->fields_defined && sql_num_fields(mdb) > 0) {
 417       mdb->fields = (SQL_FIELD **)malloc(sizeof(SQL_FIELD) * mdb->ncolumn);
 418       for (i=0; i < sql_num_fields(mdb); i++) {
 419          mdb->fields[i] = (SQL_FIELD *)malloc(sizeof(SQL_FIELD));
 420          mdb->fields[i]->name = mdb->result[i];
 421          mdb->fields[i]->length = cstrlen(mdb->fields[i]->name);
 422          mdb->fields[i]->max_length = mdb->fields[i]->length;
 423          for (j=1; j <= mdb->nrow; j++) {
 424             int len;
 425             if (mdb->result[i + mdb->ncolumn *j]) {
 426                len = (uint32_t)cstrlen(mdb->result[i + mdb->ncolumn * j]);
 427             } else {
 428                len = 0;
 429             }
 430             if (len > mdb->fields[i]->max_length) {
 431                mdb->fields[i]->max_length = len;
 432             }
 433          }
 434          mdb->fields[i]->type = 0;
 435          mdb->fields[i]->flags = 1;        /* not null */
 436       }
 437       mdb->fields_defined = TRUE;
 438    }
 439    if (field > sql_num_fields(mdb)) {
 440       field = sql_num_fields(mdb);
 441     }
 442     mdb->field = field;
 443
 444 }
 445
 446 SQL_FIELD *my_sqlite_fetch_field(B_DB *mdb)
 447 {
 448    return mdb->fields[mdb->field++];
 449 }
 450
 451 char *my_sqlite_batch_lock_query = "BEGIN";
 452 char *my_sqlite_batch_unlock_query = "COMMIT";
 453 char *my_sqlite_batch_fill_path_query = "INSERT INTO Path (Path)          "
 454                                         " SELECT DISTINCT Path FROM batch "
 455                                         " EXCEPT SELECT Path FROM Path    ";
 456
 457 char *my_sqlite_batch_fill_filename_query = "INSERT INTO Filename (Name)       "
 458                                             " SELECT DISTINCT Name FROM batch  "
 459                                             " EXCEPT SELECT Name FROM Filename ";
 460
 461
 462
 463 #endif /* HAVE_SQLITE */