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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2011 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 three of the GNU Affero 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 Affero 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  * Major rewrite by Marco van Wieringen, January 2010 for catalog refactoring.
  34  */
  35
  36 #include "bacula.h"
  37
  38 #if HAVE_SQLITE3
  39
  40 #include "cats.h"
  41 #include "bdb_priv.h"
  42 #include <sqlite3.h>
  43 #include "bdb_sqlite.h"
  44
  45 /* -----------------------------------------------------------------------
  46  *
  47  *    SQLite dependent defines and subroutines
  48  *
  49  * -----------------------------------------------------------------------
  50  */
  51
  52 /*
  53  * List of open databases
  54  */
  55 static dlist *db_list = NULL;
  56
  57 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  58
  59 /*
  60  * When using mult_db_connections = true,
  61  * sqlite can be BUSY. We just need sleep a little in this case.
  62  */
  63 static int sqlite_busy_handler(void *arg, int calls)
  64 {
  65    bmicrosleep(0, 500);
  66    return 1;
  67 }
  68
  69 B_DB_SQLITE::B_DB_SQLITE(JCR *jcr,
  70                          const char *db_driver,
  71                          const char *db_name,
  72                          const char *db_user,
  73                          const char *db_password,
  74                          const char *db_address,
  75                          int db_port,
  76                          const char *db_socket,
  77                          bool mult_db_connections,
  78                          bool disable_batch_insert)
  79 {
  80    /*
  81     * Initialize the parent class members.
  82     */
  83    m_db_interface_type = SQL_INTERFACE_TYPE_SQLITE3;
  84    m_db_type = SQL_TYPE_SQLITE3;
  85    m_db_driver = bstrdup("SQLite3");
  86    m_db_name = bstrdup(db_name);
  87    if (disable_batch_insert) {
  88       m_disabled_batch_insert = true;
  89       m_have_batch_insert = false;
  90    } else {
  91       m_disabled_batch_insert = false;
  92 #if defined(USE_BATCH_FILE_INSERT)
  93 #if defined(HAVE_SQLITE3_THREADSAFE)
  94       m_have_batch_insert = sqlite3_threadsafe();
  95 #else
  96       m_have_batch_insert = false;
  97 #endif /* HAVE_SQLITE3_THREADSAFE */
  98 #else
  99       m_have_batch_insert = false;
 100 #endif /* USE_BATCH_FILE_INSERT */
 101    }
 102    errmsg = get_pool_memory(PM_EMSG); /* get error message buffer */
 103    *errmsg = 0;
 104    cmd = get_pool_memory(PM_EMSG);    /* get command buffer */
 105    cached_path = get_pool_memory(PM_FNAME);
 106    cached_path_id = 0;
 107    m_ref_count = 1;
 108    fname = get_pool_memory(PM_FNAME);
 109    path = get_pool_memory(PM_FNAME);
 110    esc_name = get_pool_memory(PM_FNAME);
 111    esc_path = get_pool_memory(PM_FNAME);
 112    esc_obj  = get_pool_memory(PM_FNAME);
 113    m_allow_transactions = mult_db_connections;
 114
 115    /*
 116     * Initialize the private members.
 117     */
 118    m_db_handle = NULL;
 119    m_result = NULL;
 120    m_sqlite_errmsg = NULL;
 121
 122    /*
 123     * Put the db in the list.
 124     */
 125    if (db_list == NULL) {
 126       db_list = New(dlist(this, &this->m_link));
 127    }
 128    db_list->append(this);
 129 }
 130
 131 B_DB_SQLITE::~B_DB_SQLITE()
 132 {
 133 }
 134
 135 /*
 136  * Now actually open the database.  This can generate errors,
 137  * which are returned in the errmsg
 138  *
 139  * DO NOT close the database or delete mdb here !!!!
 140  */
 141 bool B_DB_SQLITE::db_open_database(JCR *jcr)
 142 {
 143    bool retval = false;
 144    char *db_path;
 145    int len;
 146    struct stat statbuf;
 147    int ret;
 148    int errstat;
 149    int retry = 0;
 150
 151    P(mutex);
 152    if (m_connected) {
 153       retval = true;
 154       goto bail_out;
 155    }
 156
 157    if ((errstat=rwl_init(&m_lock)) != 0) {
 158       berrno be;
 159       Mmsg1(&errmsg, _("Unable to initialize DB lock. ERR=%s\n"),
 160             be.bstrerror(errstat));
 161       goto bail_out;
 162    }
 163
 164    /*
 165     * Open the database
 166     */
 167    len = strlen(working_directory) + strlen(m_db_name) + 5;
 168    db_path = (char *)malloc(len);
 169    strcpy(db_path, working_directory);
 170    strcat(db_path, "/");
 171    strcat(db_path, m_db_name);
 172    strcat(db_path, ".db");
 173    if (stat(db_path, &statbuf) != 0) {
 174       Mmsg1(&errmsg, _("Database %s does not exist, please create it.\n"),
 175          db_path);
 176       free(db_path);
 177       goto bail_out;
 178    }
 179
 180    for (m_db_handle = NULL; !m_db_handle && retry++ < 10; ) {
 181       ret = sqlite3_open(db_path, &m_db_handle);
 182       if (ret != SQLITE_OK) {
 183          m_sqlite_errmsg = (char *)sqlite3_errmsg(m_db_handle);
 184          sqlite3_close(m_db_handle);
 185          m_db_handle = NULL;
 186       } else {
 187          m_sqlite_errmsg = NULL;
 188       }
 189
 190       Dmsg0(300, "sqlite_open\n");
 191       if (!m_db_handle) {
 192          bmicrosleep(1, 0);
 193       }
 194    }
 195    if (m_db_handle == NULL) {
 196       Mmsg2(&errmsg, _("Unable to open Database=%s. ERR=%s\n"),
 197          db_path, m_sqlite_errmsg ? m_sqlite_errmsg : _("unknown"));
 198       free(db_path);
 199       goto bail_out;
 200    }
 201    m_connected = true;
 202    free(db_path);
 203
 204    /*
 205     * Set busy handler to wait when we use mult_db_connections = true
 206     */
 207    sqlite3_busy_handler(m_db_handle, sqlite_busy_handler, NULL);
 208
 209 #if defined(SQLITE3_INIT_QUERY)
 210    sql_query(SQLITE3_INIT_QUERY);
 211 #endif
 212
 213    if (!check_tables_version(jcr, this)) {
 214       goto bail_out;
 215    }
 216
 217    retval = true;
 218
 219 bail_out:
 220    V(mutex);
 221    return retval;
 222 }
 223
 224 void B_DB_SQLITE::db_close_database(JCR *jcr)
 225 {
 226    db_end_transaction(jcr);
 227    P(mutex);
 228    sql_free_result();
 229    m_ref_count--;
 230    if (m_ref_count == 0) {
 231       db_list->remove(this);
 232       if (m_connected && m_db_handle) {
 233          sqlite3_close(m_db_handle);
 234       }
 235       rwl_destroy(&m_lock);
 236       free_pool_memory(errmsg);
 237       free_pool_memory(cmd);
 238       free_pool_memory(cached_path);
 239       free_pool_memory(fname);
 240       free_pool_memory(path);
 241       free_pool_memory(esc_name);
 242       free_pool_memory(esc_path);
 243       free_pool_memory(esc_obj);
 244       if (m_db_driver) {
 245          free(m_db_driver);
 246       }
 247       if (m_db_name) {
 248          free(m_db_name);
 249       }
 250       delete this;
 251       if (db_list->size() == 0) {
 252          delete db_list;
 253          db_list = NULL;
 254       }
 255    }
 256    V(mutex);
 257 }
 258
 259 void B_DB_SQLITE::db_thread_cleanup(void)
 260 {
 261    sqlite3_thread_cleanup();
 262 }
 263
 264 /*
 265  * Escape strings so that SQLite is happy
 266  *
 267  *   NOTE! len is the length of the old string. Your new
 268  *         string must be long enough (max 2*old+1) to hold
 269  *         the escaped output.
 270  */
 271 void B_DB_SQLITE::db_escape_string(JCR *jcr, char *snew, char *old, int len)
 272 {
 273    char *n, *o;
 274
 275    n = snew;
 276    o = old;
 277    while (len--) {
 278       switch (*o) {
 279       case '\'':
 280          *n++ = '\'';
 281          *n++ = '\'';
 282          o++;
 283          break;
 284       case 0:
 285          *n++ = '\\';
 286          *n++ = 0;
 287          o++;
 288          break;
 289       default:
 290          *n++ = *o++;
 291          break;
 292       }
 293    }
 294    *n = 0;
 295 }
 296
 297 /*
 298  * Escape binary object so that SQLite is happy
 299  * Memory is stored in B_DB struct, no need to free it
 300  *
 301  * TODO: this should be implemented  (escape \0)
 302  */
 303 char *B_DB_SQLITE::db_escape_object(JCR *jcr, char *old, int len)
 304 {
 305    char *n, *o;
 306
 307    n = esc_obj = check_pool_memory_size(esc_obj, len*2+1);
 308    o = old;
 309    while (len--) {
 310       switch (*o) {
 311       case '\'':
 312          *n++ = '\'';
 313          *n++ = '\'';
 314          o++;
 315          break;
 316       case 0:
 317          *n++ = '\\';
 318          *n++ = 0;
 319          o++;
 320          break;
 321       default:
 322          *n++ = *o++;
 323          break;
 324       }
 325    }
 326    *n = 0;
 327    return esc_obj;
 328 }
 329
 330 /*
 331  * Unescape binary object so that SQLIte is happy
 332  *
 333  * TODO: need to be implemented (escape \0)
 334  */
 335 void B_DB_SQLITE::db_unescape_object(JCR *jcr, char *from, int32_t expected_len,
 336                                      POOLMEM **dest, int32_t *dest_len)
 337 {
 338    if (!from) {
 339       *dest[0] = 0;
 340       *dest_len = 0;
 341       return;
 342    }
 343    *dest = check_pool_memory_size(*dest, expected_len+1);
 344    *dest_len = expected_len;
 345    memcpy(*dest, from, expected_len);
 346    (*dest)[expected_len]=0;
 347 }
 348
 349 /*
 350  * Start a transaction. This groups inserts and makes things
 351  * much more efficient. Usually started when inserting
 352  * file attributes.
 353  */
 354 void B_DB_SQLITE::db_start_transaction(JCR *jcr)
 355 {
 356    if (!jcr->attr) {
 357       jcr->attr = get_pool_memory(PM_FNAME);
 358    }
 359    if (!jcr->ar) {
 360       jcr->ar = (ATTR_DBR *)malloc(sizeof(ATTR_DBR));
 361    }
 362
 363    if (!m_allow_transactions) {
 364       return;
 365    }
 366
 367    db_lock(this);
 368    /*
 369     * Allow only 10,000 changes per transaction
 370     */
 371    if (m_transaction && changes > 10000) {
 372       db_end_transaction(jcr);
 373    }
 374    if (!m_transaction) {
 375       sql_query("BEGIN");  /* begin transaction */
 376       Dmsg0(400, "Start SQLite transaction\n");
 377       m_transaction = true;
 378    }
 379    db_unlock(this);
 380 }
 381
 382 void B_DB_SQLITE::db_end_transaction(JCR *jcr)
 383 {
 384    if (jcr && jcr->cached_attribute) {
 385       Dmsg0(400, "Flush last cached attribute.\n");
 386       if (!db_create_attributes_record(jcr, this, jcr->ar)) {
 387          Jmsg1(jcr, M_FATAL, 0, _("Attribute create error. %s"), db_strerror(jcr->db));
 388       }
 389       jcr->cached_attribute = false;
 390    }
 391
 392    if (!m_allow_transactions) {
 393       return;
 394    }
 395
 396    db_lock(this);
 397    if (m_transaction) {
 398       sql_query("COMMIT"); /* end transaction */
 399       m_transaction = false;
 400       Dmsg1(400, "End SQLite transaction changes=%d\n", changes);
 401    }
 402    changes = 0;
 403    db_unlock(this);
 404 }
 405
 406 struct rh_data {
 407    DB_RESULT_HANDLER *result_handler;
 408    void *ctx;
 409 };
 410
 411 /*
 412  * Convert SQLite's callback into Bacula DB callback
 413  */
 414 static int sqlite_sqlite_result(void *arh_data, int num_fields, char **rows, char **col_names)
 415 {
 416    struct rh_data *rh_data = (struct rh_data *)arh_data;
 417
 418    if (rh_data->result_handler) {
 419       (*(rh_data->result_handler))(rh_data->ctx, num_fields, rows);
 420    }
 421    return 0;
 422 }
 423
 424 /*
 425  * Submit a general SQL command (cmd), and for each row returned,
 426  *  the result_handler is called with the ctx.
 427  */
 428 bool B_DB_SQLITE::db_sql_query(const char *query, DB_RESULT_HANDLER *result_handler, void *ctx)
 429 {
 430    bool retval = false;
 431    int stat;
 432    struct rh_data rh_data;
 433
 434    Dmsg1(500, "db_sql_query starts with '%s'\n", query);
 435
 436    db_lock(this);
 437    if (m_sqlite_errmsg) {
 438       sqlite3_free(m_sqlite_errmsg);
 439       m_sqlite_errmsg = NULL;
 440    }
 441    rh_data.result_handler = result_handler;
 442    rh_data.ctx = ctx;
 443    stat = sqlite3_exec(m_db_handle, query, sqlite_sqlite_result, (void *)&rh_data, &m_sqlite_errmsg);
 444    if (stat != SQLITE_OK) {
 445       Mmsg(errmsg, _("Query failed: %s: ERR=%s\n"), query, sql_strerror());
 446       Dmsg0(500, "db_sql_query finished\n");
 447       goto bail_out;
 448    }
 449    Dmsg0(500, "db_sql_query finished\n");
 450    retval = true;
 451
 452 bail_out:
 453    db_unlock(this);
 454    return retval;
 455 }
 456
 457 /*
 458  * Submit a sqlite query and retrieve all the data
 459  */
 460 bool B_DB_SQLITE::sql_query(const char *query, int flags)
 461 {
 462    int stat;
 463    bool retval = false;
 464
 465    Dmsg1(500, "sql_query starts with '%s'\n", query);
 466
 467    if (m_result) {
 468       sql_free_result();
 469    }
 470    if (m_sqlite_errmsg) {
 471       sqlite3_free(m_sqlite_errmsg);
 472       m_sqlite_errmsg = NULL;
 473    }
 474
 475    stat = sqlite3_get_table(m_db_handle, (char *)query, &m_result,
 476                             &m_num_rows, &m_num_fields, &m_sqlite_errmsg);
 477
 478    m_row_number = 0;               /* no row fetched */
 479    if (stat != 0) {                   /* something went wrong */
 480       m_num_rows = m_num_fields = 0;
 481       Dmsg0(500, "sql_query finished\n");
 482    } else {
 483       Dmsg0(500, "sql_query finished\n");
 484       retval = true;
 485    }
 486    return retval;
 487 }
 488
 489 void B_DB_SQLITE::sql_free_result(void)
 490 {
 491    db_lock(this);
 492    if (m_fields) {
 493       free(m_fields);
 494       m_fields = NULL;
 495    }
 496    if (m_result) {
 497       sqlite3_free_table(m_result);
 498       m_result = NULL;
 499    }
 500    m_num_rows = m_num_fields = 0;
 501    db_unlock(this);
 502 }
 503
 504 /*
 505  * Fetch one row at a time
 506  */
 507 SQL_ROW B_DB_SQLITE::sql_fetch_row(void)
 508 {
 509    if (!m_result || (m_row_number >= m_num_rows)) {
 510       return NULL;
 511    }
 512    m_row_number++;
 513    return &m_result[m_num_fields * m_row_number];
 514 }
 515
 516 const char *B_DB_SQLITE::sql_strerror(void)
 517 {
 518    return m_sqlite_errmsg ? m_sqlite_errmsg : "unknown";
 519 }
 520
 521 void B_DB_SQLITE::sql_data_seek(int row)
 522 {
 523    /*
 524     * Set the row number to be returned on the next call to sql_fetch_row
 525     */
 526    m_row_number = row;
 527 }
 528
 529 int B_DB_SQLITE::sql_affected_rows(void)
 530 {
 531    return sqlite3_changes(m_db_handle);
 532 }
 533
 534 uint64_t B_DB_SQLITE::sql_insert_autokey_record(const char *query, const char *table_name)
 535 {
 536    /*
 537     * First execute the insert query and then retrieve the currval.
 538     */
 539    if (!sql_query(query)) {
 540       return 0;
 541    }
 542
 543    m_num_rows = sql_affected_rows();
 544    if (m_num_rows != 1) {
 545       return 0;
 546    }
 547
 548    changes++;
 549
 550    return sqlite3_last_insert_rowid(m_db_handle);
 551 }
 552
 553 SQL_FIELD *B_DB_SQLITE::sql_fetch_field(void)
 554 {
 555    int i, j, len;
 556
 557    if (!m_fields || m_fields_size < m_num_fields) {
 558       if (m_fields) {
 559          free(m_fields);
 560          m_fields = NULL;
 561       }
 562       Dmsg1(500, "allocating space for %d fields\n", m_num_fields);
 563       m_fields = (SQL_FIELD *)malloc(sizeof(SQL_FIELD) * m_num_fields);
 564       m_fields_size = m_num_fields;
 565
 566       for (i = 0; i < m_num_fields; i++) {
 567          Dmsg1(500, "filling field %d\n", i);
 568          m_fields[i].name = m_result[i];
 569          m_fields[i].max_length = cstrlen(m_fields[i].name);
 570          for (j = 1; j <= m_num_rows; j++) {
 571             if (m_result[i + m_num_fields * j]) {
 572                len = (uint32_t)cstrlen(m_result[i + m_num_fields * j]);
 573             } else {
 574                len = 0;
 575             }
 576             if (len > m_fields[i].max_length) {
 577                m_fields[i].max_length = len;
 578             }
 579          }
 580          m_fields[i].type = 0;
 581          m_fields[i].flags = 1;        /* not null */
 582
 583          Dmsg4(500, "sql_fetch_field finds field '%s' has length='%d' type='%d' and IsNull=%d\n",
 584                m_fields[i].name, m_fields[i].max_length, m_fields[i].type, m_fields[i].flags);
 585       }
 586    }
 587
 588    /*
 589     * Increment field number for the next time around
 590     */
 591    return &m_fields[m_field_number++];
 592 }
 593
 594 bool B_DB_SQLITE::sql_field_is_not_null(int field_type)
 595 {
 596    switch (field_type) {
 597    case 1:
 598       return true;
 599    default:
 600       return false;
 601    }
 602 }
 603
 604 bool B_DB_SQLITE::sql_field_is_numeric(int field_type)
 605 {
 606    switch (field_type) {
 607    case 1:
 608       return true;
 609    default:
 610       return false;
 611    }
 612 }
 613
 614 /*
 615  * Returns true if OK
 616  *         false if failed
 617  */
 618 bool B_DB_SQLITE::sql_batch_start(JCR *jcr)
 619 {
 620    bool retval;
 621
 622    db_lock(this);
 623    retval = sql_query("CREATE TEMPORARY TABLE batch ("
 624                               "FileIndex integer,"
 625                               "JobId integer,"
 626                               "Path blob,"
 627                               "Name blob,"
 628                               "LStat tinyblob,"
 629                               "MD5 tinyblob,"
 630                               "MarkId integer)");
 631    db_unlock(this);
 632
 633    return retval;
 634 }
 635
 636 /* set error to something to abort operation */
 637 /*
 638  * Returns true if OK
 639  *         false if failed
 640  */
 641 bool B_DB_SQLITE::sql_batch_end(JCR *jcr, const char *error)
 642 {
 643    m_status = 0;
 644
 645    return true;
 646 }
 647
 648 /*
 649  * Returns true if OK
 650  *         false if failed
 651  */
 652 bool B_DB_SQLITE::sql_batch_insert(JCR *jcr, ATTR_DBR *ar)
 653 {
 654    size_t len;
 655    const char *digest;
 656    char ed1[50];
 657
 658    esc_name = check_pool_memory_size(esc_name, fnl*2+1);
 659    db_escape_string(jcr, esc_name, fname, fnl);
 660
 661    esc_path = check_pool_memory_size(esc_path, pnl*2+1);
 662    db_escape_string(jcr, esc_path, path, pnl);
 663
 664    if (ar->Digest == NULL || ar->Digest[0] == 0) {
 665       digest = "0";
 666    } else {
 667       digest = ar->Digest;
 668    }
 669
 670    len = Mmsg(cmd, "INSERT INTO batch VALUES "
 671                    "(%u,%s,'%s','%s','%s','%s',%u)",
 672                    ar->FileIndex, edit_int64(ar->JobId,ed1), esc_path,
 673                    esc_name, ar->attr, digest, ar->DeltaSeq);
 674
 675    return sql_query(cmd);
 676 }
 677
 678 /*
 679  * Initialize database data structure. In principal this should
 680  * never have errors, or it is really fatal.
 681  */
 682 B_DB *db_init_database(JCR *jcr, const char *db_driver, const char *db_name,
 683                        const char *db_user, const char *db_password,
 684                        const char *db_address, int db_port,
 685                        const char *db_socket, bool mult_db_connections,
 686                        bool disable_batch_insert)
 687 {
 688    B_DB *mdb = NULL;
 689
 690    P(mutex);                          /* lock DB queue */
 691    /*
 692     * Look to see if DB already open
 693     */
 694    if (db_list && !mult_db_connections) {
 695       foreach_dlist(mdb, db_list) {
 696          if (mdb->db_match_database(db_driver, db_name, db_address, db_port)) {
 697             Dmsg1(300, "DB REopen %s\n", db_name);
 698             mdb->increment_refcount();
 699             goto bail_out;
 700          }
 701       }
 702    }
 703    Dmsg0(300, "db_init_database first time\n");
 704    mdb = New(B_DB_SQLITE(jcr, db_driver, db_name, db_user, db_password,
 705                          db_address, db_port, db_socket, mult_db_connections,
 706                          disable_batch_insert));
 707
 708 bail_out:
 709    V(mutex);
 710    return mdb;
 711 }
 712
 713 #endif /* HAVE_SQLITE3 */