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

   1 /*
   2  * Bacula Catalog Database routines specific to SQLite
   3  *
   4  *    Kern Sibbald, January 2002
   5  *
   6  *    Version $Id$
   7  */
   8 /*
   9    Bacula® - The Network Backup Solution
  10
  11    Copyright (C) 2000-2006 Free Software Foundation Europe e.V.
  12
  13    The main author of Bacula is Kern Sibbald, with contributions from
  14    many others, a complete list can be found in the file AUTHORS.
  15    This program is Free Software; you can redistribute it and/or
  16    modify it under the terms of version two of the GNU General Public
  17    License as published by the Free Software Foundation plus additions
  18    that are listed in the file LICENSE.
  19
  20    This program is distributed in the hope that it will be useful, but
  21    WITHOUT ANY WARRANTY; without even the implied warranty of
  22    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  23    General Public License for more details.
  24
  25    You should have received a copy of the GNU General Public License
  26    along with this program; if not, write to the Free Software
  27    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  28    02110-1301, USA.
  29
  30    Bacula® is a registered trademark of John Walker.
  31    The licensor of Bacula is the Free Software Foundation Europe
  32    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  33    Switzerland, email:ftf@fsfeurope.org.
  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->allow_transactions = mult_db_connections;
 112    qinsert(&db_list, &mdb->bq);            /* put db in list */
 113    V(mutex);
 114    return mdb;
 115 }
 116
 117 /*
 118  * Now actually open the database.  This can generate errors,
 119  * which are returned in the errmsg
 120  *
 121  * DO NOT close the database or free(mdb) here !!!!
 122  */
 123 int
 124 db_open_database(JCR *jcr, B_DB *mdb)
 125 {
 126    char *db_name;
 127    int len;
 128    struct stat statbuf;
 129    int errstat;
 130
 131    P(mutex);
 132    if (mdb->connected) {
 133       V(mutex);
 134       return 1;
 135    }
 136    mdb->connected = FALSE;
 137
 138    if ((errstat=rwl_init(&mdb->lock)) != 0) {
 139       Mmsg1(&mdb->errmsg, _("Unable to initialize DB lock. ERR=%s\n"),
 140             strerror(errstat));
 141       V(mutex);
 142       return 0;
 143    }
 144
 145    /* open the database */
 146    len = strlen(working_directory) + strlen(mdb->db_name) + 5;
 147    db_name = (char *)malloc(len);
 148    strcpy(db_name, working_directory);
 149    strcat(db_name, "/");
 150    strcat(db_name, mdb->db_name);
 151    strcat(db_name, ".db");
 152    if (stat(db_name, &statbuf) != 0) {
 153       Mmsg1(&mdb->errmsg, _("Database %s does not exist, please create it.\n"),
 154          db_name);
 155       free(db_name);
 156       V(mutex);
 157       return 0;
 158    }
 159
 160 #ifdef HAVE_SQLITE3
 161    int stat = sqlite3_open(db_name, &mdb->db);
 162    if (stat != SQLITE_OK) {
 163       mdb->sqlite_errmsg = (char *)sqlite3_errmsg(mdb->db);
 164    } else {
 165       mdb->sqlite_errmsg = NULL;
 166    }
 167
 168 #else
 169    mdb->db = sqlite_open(
 170         db_name,                      /* database name */
 171         644,                          /* mode */
 172         &mdb->sqlite_errmsg);         /* error message */
 173 #endif
 174
 175    Dmsg0(300, "sqlite_open\n");
 176
 177    if (mdb->db == NULL) {
 178       Mmsg2(&mdb->errmsg, _("Unable to open Database=%s. ERR=%s\n"),
 179          db_name, mdb->sqlite_errmsg ? mdb->sqlite_errmsg : _("unknown"));
 180       free(db_name);
 181       V(mutex);
 182       return 0;
 183    }
 184    free(db_name);
 185    if (!check_tables_version(jcr, mdb)) {
 186       V(mutex);
 187       return 0;
 188    }
 189
 190    mdb->connected = true;
 191    V(mutex);
 192    return 1;
 193 }
 194
 195 void
 196 db_close_database(JCR *jcr, B_DB *mdb)
 197 {
 198    if (!mdb) {
 199       return;
 200    }
 201    db_end_transaction(jcr, mdb);
 202    P(mutex);
 203    mdb->ref_count--;
 204    if (mdb->ref_count == 0) {
 205       qdchain(&mdb->bq);
 206       if (mdb->connected && mdb->db) {
 207          sqlite_close(mdb->db);
 208       }
 209       rwl_destroy(&mdb->lock);
 210       free_pool_memory(mdb->errmsg);
 211       free_pool_memory(mdb->cmd);
 212       free_pool_memory(mdb->cached_path);
 213       free_pool_memory(mdb->fname);
 214       free_pool_memory(mdb->path);
 215       free_pool_memory(mdb->esc_name);
 216       if (mdb->db_name) {
 217          free(mdb->db_name);
 218       }
 219       free(mdb);
 220    }
 221    V(mutex);
 222 }
 223
 224 /*
 225  * Return the next unique index (auto-increment) for
 226  * the given table.  Return 0 on error.
 227  */
 228 int db_next_index(JCR *jcr, B_DB *mdb, char *table, char *index)
 229 {
 230 #ifdef xxxx
 231    SQL_ROW row;
 232
 233    db_lock(mdb);
 234
 235    Mmsg(mdb->cmd,
 236 "SELECT id FROM NextId WHERE TableName=\"%s\"", table);
 237    if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
 238       Mmsg(mdb->errmsg, _("next_index query error: ERR=%s\n"), sql_strerror(mdb));
 239       db_unlock(mdb);
 240       return 0;
 241    }
 242    if ((row = sql_fetch_row(mdb)) == NULL) {
 243       Mmsg(mdb->errmsg, _("Error fetching index: ERR=%s\n"), sql_strerror(mdb));
 244       db_unlock(mdb);
 245       return 0;
 246    }
 247    bstrncpy(index, row[0], 28);
 248    sql_free_result(mdb);
 249
 250    Mmsg(mdb->cmd,
 251 "UPDATE NextId SET id=id+1 WHERE TableName=\"%s\"", table);
 252    if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
 253       Mmsg(mdb->errmsg, _("next_index update error: ERR=%s\n"), sql_strerror(mdb));
 254       db_unlock(mdb);
 255       return 0;
 256    }
 257    sql_free_result(mdb);
 258
 259    db_unlock(mdb);
 260 #endif
 261    strcpy(index, "NULL");
 262    return 1;
 263 }
 264
 265
 266 /*
 267  * Escape strings so that SQLite is happy
 268  *
 269  *   NOTE! len is the length of the old string. Your new
 270  *         string must be long enough (max 2*old+1) to hold
 271  *         the escaped output.
 272  */
 273 void
 274 db_escape_string(char *snew, char *old, int len)
 275 {
 276    char *n, *o;
 277
 278    n = snew;
 279    o = old;
 280    while (len--) {
 281       switch (*o) {
 282       case '\'':
 283          *n++ = '\'';
 284          *n++ = '\'';
 285          o++;
 286          break;
 287       case 0:
 288          *n++ = '\\';
 289          *n++ = 0;
 290          o++;
 291          break;
 292       default:
 293          *n++ = *o++;
 294          break;
 295       }
 296    }
 297    *n = 0;
 298 }
 299
 300 struct rh_data {
 301    DB_RESULT_HANDLER *result_handler;
 302    void *ctx;
 303 };
 304
 305 /*
 306  * Convert SQLite's callback into Bacula DB callback
 307  */
 308 static int sqlite_result(void *arh_data, int num_fields, char **rows, char **col_names)
 309 {
 310    struct rh_data *rh_data = (struct rh_data *)arh_data;
 311
 312    if (rh_data->result_handler) {
 313       (*(rh_data->result_handler))(rh_data->ctx, num_fields, rows);
 314    }
 315    return 0;
 316 }
 317
 318 /*
 319  * Submit a general SQL command (cmd), and for each row returned,
 320  *  the sqlite_handler is called with the ctx.
 321  */
 322 int db_sql_query(B_DB *mdb, const char *query, DB_RESULT_HANDLER *result_handler, void *ctx)
 323 {
 324    struct rh_data rh_data;
 325    int stat;
 326
 327    db_lock(mdb);
 328    if (mdb->sqlite_errmsg) {
 329 #ifdef HAVE_SQLITE3
 330       sqlite3_free(mdb->sqlite_errmsg);
 331 #else
 332       actuallyfree(mdb->sqlite_errmsg);
 333 #endif
 334       mdb->sqlite_errmsg = NULL;
 335    }
 336    rh_data.result_handler = result_handler;
 337    rh_data.ctx = ctx;
 338    stat = sqlite_exec(mdb->db, query, sqlite_result, (void *)&rh_data, &mdb->sqlite_errmsg);
 339    if (stat != 0) {
 340       Mmsg(mdb->errmsg, _("Query failed: %s: ERR=%s\n"), query, sql_strerror(mdb));
 341       db_unlock(mdb);
 342       return 0;
 343    }
 344    db_unlock(mdb);
 345    return 1;
 346 }
 347
 348 /*
 349  * Submit a sqlite query and retrieve all the data
 350  */
 351 int my_sqlite_query(B_DB *mdb, const char *cmd)
 352 {
 353    int stat;
 354
 355    if (mdb->sqlite_errmsg) {
 356 #ifdef HAVE_SQLITE3
 357       sqlite3_free(mdb->sqlite_errmsg);
 358 #else
 359       actuallyfree(mdb->sqlite_errmsg);
 360 #endif
 361       mdb->sqlite_errmsg = NULL;
 362    }
 363    stat = sqlite_get_table(mdb->db, (char *)cmd, &mdb->result, &mdb->nrow, &mdb->ncolumn,
 364             &mdb->sqlite_errmsg);
 365    mdb->row = 0;                      /* row fetched */
 366    return stat;
 367 }
 368
 369 /* Fetch one row at a time */
 370 SQL_ROW my_sqlite_fetch_row(B_DB *mdb)
 371 {
 372    if (mdb->row >= mdb->nrow) {
 373       return NULL;
 374    }
 375    mdb->row++;
 376    return &mdb->result[mdb->ncolumn * mdb->row];
 377 }
 378
 379 void my_sqlite_free_table(B_DB *mdb)
 380 {
 381    int i;
 382
 383    if (mdb->fields_defined) {
 384       for (i=0; i < sql_num_fields(mdb); i++) {
 385          free(mdb->fields[i]);
 386       }
 387       free(mdb->fields);
 388       mdb->fields_defined = false;
 389    }
 390    sqlite_free_table(mdb->result);
 391    mdb->nrow = mdb->ncolumn = 0;
 392 }
 393
 394 void my_sqlite_field_seek(B_DB *mdb, int field)
 395 {
 396    int i, j;
 397    if (mdb->result == NULL) {
 398       return;
 399    }
 400    /* On first call, set up the fields */
 401    if (!mdb->fields_defined && sql_num_fields(mdb) > 0) {
 402       mdb->fields = (SQL_FIELD **)malloc(sizeof(SQL_FIELD) * mdb->ncolumn);
 403       for (i=0; i < sql_num_fields(mdb); i++) {
 404          mdb->fields[i] = (SQL_FIELD *)malloc(sizeof(SQL_FIELD));
 405          mdb->fields[i]->name = mdb->result[i];
 406          mdb->fields[i]->length = cstrlen(mdb->fields[i]->name);
 407          mdb->fields[i]->max_length = mdb->fields[i]->length;
 408          for (j=1; j <= mdb->nrow; j++) {
 409             int len;
 410             if (mdb->result[i + mdb->ncolumn *j]) {
 411                len = (uint32_t)cstrlen(mdb->result[i + mdb->ncolumn * j]);
 412             } else {
 413                len = 0;
 414             }
 415             if (len > mdb->fields[i]->max_length) {
 416                mdb->fields[i]->max_length = len;
 417             }
 418          }
 419          mdb->fields[i]->type = 0;
 420          mdb->fields[i]->flags = 1;        /* not null */
 421       }
 422       mdb->fields_defined = TRUE;
 423    }
 424    if (field > sql_num_fields(mdb)) {
 425       field = sql_num_fields(mdb);
 426     }
 427     mdb->field = field;
 428
 429 }
 430
 431 SQL_FIELD *my_sqlite_fetch_field(B_DB *mdb)
 432 {
 433    return mdb->fields[mdb->field++];
 434 }
 435
 436 #endif /* HAVE_SQLITE */