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  * Initialize database data structure. In principal this should
  74  * never have errors, or it is really fatal.
  75  */
  76 B_DB *
  77 db_init_database(JCR *jcr, const char *db_name, const char *db_user, const char *db_password,
  78                  const char *db_address, int db_port, const char *db_socket,
  79                  int mult_db_connections)
  80 {
  81    B_DB *mdb;
  82
  83    P(mutex);                          /* lock DB queue */
  84    /* Look to see if DB already open */
  85    if (!mult_db_connections) {
  86       for (mdb=NULL; (mdb=(B_DB *)qnext(&db_list, &mdb->bq)); ) {
  87          if (bstrcmp(mdb->db_name, db_name) &&
  88              bstrcmp(mdb->db_address, db_address) &&
  89              mdb->db_port == db_port) {
  90             Dmsg2(300, "DB REopen %d %s\n", mdb->ref_count, db_name);
  91             mdb->ref_count++;
  92             V(mutex);
  93             return mdb;                  /* already open */
  94          }
  95       }
  96    }
  97    Dmsg0(300, "db_open first time\n");
  98    mdb = (B_DB *) malloc(sizeof(B_DB));
  99    memset(mdb, 0, sizeof(B_DB));
 100    mdb->db_name = bstrdup(db_name);
 101    mdb->have_insert_id = TRUE;
 102    mdb->errmsg = get_pool_memory(PM_EMSG); /* get error message buffer */
 103    *mdb->errmsg = 0;
 104    mdb->cmd = get_pool_memory(PM_EMSG);    /* get command buffer */
 105    mdb->cached_path = get_pool_memory(PM_FNAME);
 106    mdb->cached_path_id = 0;
 107    mdb->ref_count = 1;
 108    mdb->fname = get_pool_memory(PM_FNAME);
 109    mdb->path = get_pool_memory(PM_FNAME);
 110    mdb->esc_name = get_pool_memory(PM_FNAME);
 111    mdb->esc_name2 = get_pool_memory(PM_FNAME);
 112    mdb->allow_transactions = mult_db_connections;
 113    qinsert(&db_list, &mdb->bq);            /* put db in list */
 114    V(mutex);
 115    return mdb;
 116 }
 117
 118 /*
 119  * Now actually open the database.  This can generate errors,
 120  * which are returned in the errmsg
 121  *
 122  * DO NOT close the database or free(mdb) here !!!!
 123  */
 124 int
 125 db_open_database(JCR *jcr, B_DB *mdb)
 126 {
 127    char *db_name;
 128    int len;
 129    struct stat statbuf;
 130    int errstat;
 131
 132    P(mutex);
 133    if (mdb->connected) {
 134       V(mutex);
 135       return 1;
 136    }
 137    mdb->connected = FALSE;
 138
 139    if ((errstat=rwl_init(&mdb->lock)) != 0) {
 140       Mmsg1(&mdb->errmsg, _("Unable to initialize DB lock. ERR=%s\n"),
 141             strerror(errstat));
 142       V(mutex);
 143       return 0;
 144    }
 145
 146    /* open the database */
 147    len = strlen(working_directory) + strlen(mdb->db_name) + 5;
 148    db_name = (char *)malloc(len);
 149    strcpy(db_name, working_directory);
 150    strcat(db_name, "/");
 151    strcat(db_name, mdb->db_name);
 152    strcat(db_name, ".db");
 153    if (stat(db_name, &statbuf) != 0) {
 154       Mmsg1(&mdb->errmsg, _("Database %s does not exist, please create it.\n"),
 155          db_name);
 156       free(db_name);
 157       V(mutex);
 158       return 0;
 159    }
 160
 161 #ifdef HAVE_SQLITE3
 162    int stat = sqlite3_open(db_name, &mdb->db);
 163    if (stat != SQLITE_OK) {
 164       mdb->sqlite_errmsg = (char *)sqlite3_errmsg(mdb->db);
 165       sqlite3_close(mdb->db);
 166       mdb->db = NULL;
 167    } else {
 168       mdb->sqlite_errmsg = NULL;
 169    }
 170
 171 #else
 172    mdb->db = sqlite_open(
 173         db_name,                      /* database name */
 174         644,                          /* mode */
 175         &mdb->sqlite_errmsg);         /* error message */
 176 #endif
 177
 178    Dmsg0(300, "sqlite_open\n");
 179
 180    if (mdb->db == NULL) {
 181       Mmsg2(&mdb->errmsg, _("Unable to open Database=%s. ERR=%s\n"),
 182          db_name, mdb->sqlite_errmsg ? mdb->sqlite_errmsg : _("unknown"));
 183       free(db_name);
 184       V(mutex);
 185       return 0;
 186    }
 187    free(db_name);
 188    if (!check_tables_version(jcr, mdb)) {
 189       V(mutex);
 190       return 0;
 191    }
 192
 193    mdb->connected = true;
 194    V(mutex);
 195    return 1;
 196 }
 197
 198 void
 199 db_close_database(JCR *jcr, B_DB *mdb)
 200 {
 201    if (!mdb) {
 202       return;
 203    }
 204    db_end_transaction(jcr, mdb);
 205    P(mutex);
 206    mdb->ref_count--;
 207    if (mdb->ref_count == 0) {
 208       qdchain(&mdb->bq);
 209       if (mdb->connected && mdb->db) {
 210          sqlite_close(mdb->db);
 211       }
 212       rwl_destroy(&mdb->lock);
 213       free_pool_memory(mdb->errmsg);
 214       free_pool_memory(mdb->cmd);
 215       free_pool_memory(mdb->cached_path);
 216       free_pool_memory(mdb->fname);
 217       free_pool_memory(mdb->path);
 218       free_pool_memory(mdb->esc_name);
 219       free_pool_memory(mdb->esc_name2);
 220       if (mdb->db_name) {
 221          free(mdb->db_name);
 222       }
 223       free(mdb);
 224    }
 225    V(mutex);
 226 }
 227
 228 /*
 229  * Return the next unique index (auto-increment) for
 230  * the given table.  Return 0 on error.
 231  */
 232 int db_next_index(JCR *jcr, B_DB *mdb, char *table, char *index)
 233 {
 234 #ifdef xxxx
 235    SQL_ROW row;
 236
 237    db_lock(mdb);
 238
 239    Mmsg(mdb->cmd,
 240 "SELECT id FROM NextId WHERE TableName=\"%s\"", table);
 241    if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
 242       Mmsg(mdb->errmsg, _("next_index query error: ERR=%s\n"), sql_strerror(mdb));
 243       db_unlock(mdb);
 244       return 0;
 245    }
 246    if ((row = sql_fetch_row(mdb)) == NULL) {
 247       Mmsg(mdb->errmsg, _("Error fetching index: ERR=%s\n"), sql_strerror(mdb));
 248       db_unlock(mdb);
 249       return 0;
 250    }
 251    bstrncpy(index, row[0], 28);
 252    sql_free_result(mdb);
 253
 254    Mmsg(mdb->cmd,
 255 "UPDATE NextId SET id=id+1 WHERE TableName=\"%s\"", table);
 256    if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
 257       Mmsg(mdb->errmsg, _("next_index update error: ERR=%s\n"), sql_strerror(mdb));
 258       db_unlock(mdb);
 259       return 0;
 260    }
 261    sql_free_result(mdb);
 262
 263    db_unlock(mdb);
 264 #endif
 265    strcpy(index, "NULL");
 266    return 1;
 267 }
 268
 269
 270 /*
 271  * Escape strings so that SQLite is happy
 272  *
 273  *   NOTE! len is the length of the old string. Your new
 274  *         string must be long enough (max 2*old+1) to hold
 275  *         the escaped output.
 276  */
 277 void
 278 db_escape_string(char *snew, char *old, int len)
 279 {
 280    char *n, *o;
 281
 282    n = snew;
 283    o = old;
 284    while (len--) {
 285       switch (*o) {
 286       case '\'':
 287          *n++ = '\'';
 288          *n++ = '\'';
 289          o++;
 290          break;
 291       case 0:
 292          *n++ = '\\';
 293          *n++ = 0;
 294          o++;
 295          break;
 296       default:
 297          *n++ = *o++;
 298          break;
 299       }
 300    }
 301    *n = 0;
 302 }
 303
 304 struct rh_data {
 305    DB_RESULT_HANDLER *result_handler;
 306    void *ctx;
 307 };
 308
 309 /*
 310  * Convert SQLite's callback into Bacula DB callback
 311  */
 312 static int sqlite_result(void *arh_data, int num_fields, char **rows, char **col_names)
 313 {
 314    struct rh_data *rh_data = (struct rh_data *)arh_data;
 315
 316    if (rh_data->result_handler) {
 317       (*(rh_data->result_handler))(rh_data->ctx, num_fields, rows);
 318    }
 319    return 0;
 320 }
 321
 322 /*
 323  * Submit a general SQL command (cmd), and for each row returned,
 324  *  the sqlite_handler is called with the ctx.
 325  */
 326 int db_sql_query(B_DB *mdb, const char *query, DB_RESULT_HANDLER *result_handler, void *ctx)
 327 {
 328    struct rh_data rh_data;
 329    int stat;
 330
 331    db_lock(mdb);
 332    if (mdb->sqlite_errmsg) {
 333 #ifdef HAVE_SQLITE3
 334       sqlite3_free(mdb->sqlite_errmsg);
 335 #else
 336       actuallyfree(mdb->sqlite_errmsg);
 337 #endif
 338       mdb->sqlite_errmsg = NULL;
 339    }
 340    rh_data.result_handler = result_handler;
 341    rh_data.ctx = ctx;
 342    stat = sqlite_exec(mdb->db, query, sqlite_result, (void *)&rh_data, &mdb->sqlite_errmsg);
 343    if (stat != 0) {
 344       Mmsg(mdb->errmsg, _("Query failed: %s: ERR=%s\n"), query, sql_strerror(mdb));
 345       db_unlock(mdb);
 346       return 0;
 347    }
 348    db_unlock(mdb);
 349    return 1;
 350 }
 351
 352 /*
 353  * Submit a sqlite query and retrieve all the data
 354  */
 355 int my_sqlite_query(B_DB *mdb, const char *cmd)
 356 {
 357    int stat;
 358
 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    stat = sqlite_get_table(mdb->db, (char *)cmd, &mdb->result, &mdb->nrow, &mdb->ncolumn,
 368             &mdb->sqlite_errmsg);
 369    mdb->row = 0;                      /* row fetched */
 370    return stat;
 371 }
 372
 373 /* Fetch one row at a time */
 374 SQL_ROW my_sqlite_fetch_row(B_DB *mdb)
 375 {
 376    if (mdb->row >= mdb->nrow) {
 377       return NULL;
 378    }
 379    mdb->row++;
 380    return &mdb->result[mdb->ncolumn * mdb->row];
 381 }
 382
 383 void my_sqlite_free_table(B_DB *mdb)
 384 {
 385    int i;
 386
 387    if (mdb->fields_defined) {
 388       for (i=0; i < sql_num_fields(mdb); i++) {
 389          free(mdb->fields[i]);
 390       }
 391       free(mdb->fields);
 392       mdb->fields_defined = false;
 393    }
 394    sqlite_free_table(mdb->result);
 395    mdb->nrow = mdb->ncolumn = 0;
 396 }
 397
 398 void my_sqlite_field_seek(B_DB *mdb, int field)
 399 {
 400    int i, j;
 401    if (mdb->result == NULL) {
 402       return;
 403    }
 404    /* On first call, set up the fields */
 405    if (!mdb->fields_defined && sql_num_fields(mdb) > 0) {
 406       mdb->fields = (SQL_FIELD **)malloc(sizeof(SQL_FIELD) * mdb->ncolumn);
 407       for (i=0; i < sql_num_fields(mdb); i++) {
 408          mdb->fields[i] = (SQL_FIELD *)malloc(sizeof(SQL_FIELD));
 409          mdb->fields[i]->name = mdb->result[i];
 410          mdb->fields[i]->length = cstrlen(mdb->fields[i]->name);
 411          mdb->fields[i]->max_length = mdb->fields[i]->length;
 412          for (j=1; j <= mdb->nrow; j++) {
 413             int len;
 414             if (mdb->result[i + mdb->ncolumn *j]) {
 415                len = (uint32_t)cstrlen(mdb->result[i + mdb->ncolumn * j]);
 416             } else {
 417                len = 0;
 418             }
 419             if (len > mdb->fields[i]->max_length) {
 420                mdb->fields[i]->max_length = len;
 421             }
 422          }
 423          mdb->fields[i]->type = 0;
 424          mdb->fields[i]->flags = 1;        /* not null */
 425       }
 426       mdb->fields_defined = TRUE;
 427    }
 428    if (field > sql_num_fields(mdb)) {
 429       field = sql_num_fields(mdb);
 430     }
 431     mdb->field = field;
 432
 433 }
 434
 435 SQL_FIELD *my_sqlite_fetch_field(B_DB *mdb)
 436 {
 437    return mdb->fields[mdb->field++];
 438 }
 439
 440 char *my_sqlite_batch_lock_query = "BEGIN";
 441 char *my_sqlite_batch_unlock_query = "COMMIT";
 442 char *my_sqlite_batch_fill_path_query = "INSERT INTO Path (Path)          "
 443                                         " SELECT DISTINCT Path FROM batch "
 444                                         " EXCEPT SELECT Path FROM Path    ";
 445
 446 char *my_sqlite_batch_fill_filename_query = "INSERT INTO Filename (Name)       "
 447                                             " SELECT DISTINCT Name FROM batch  "
 448                                             " EXCEPT SELECT Name FROM Filename ";
 449
 450
 451
 452 #endif /* HAVE_SQLITE */