git.sur5r.net Git - bacula/bacula/blob - bacula/src/cats/mysql.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 MySQL
  30  *   These are MySQL specific routines -- hopefully all
  31  *    other files are generic.
  32  *
  33  *    Kern Sibbald, March 2000
  34  *
  35  * Major rewrite by Marco van Wieringen, January 2010 for catalog refactoring.
  36  */
  37
  38 #include "bacula.h"
  39
  40 #ifdef HAVE_MYSQL
  41
  42 #include "cats.h"
  43 #include "bdb_priv.h"
  44 #include <mysql.h>
  45 #include <bdb_mysql.h>
  46
  47 /* -----------------------------------------------------------------------
  48  *
  49  *   MySQL dependent defines and subroutines
  50  *
  51  * -----------------------------------------------------------------------
  52  */
  53
  54 /*
  55  * List of open databases
  56  */
  57 static dlist *db_list = NULL;
  58
  59 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  60
  61 B_DB_MYSQL::B_DB_MYSQL(JCR *jcr,
  62                        const char *db_driver,
  63                        const char *db_name,
  64                        const char *db_user,
  65                        const char *db_password,
  66                        const char *db_address,
  67                        int db_port,
  68                        const char *db_socket,
  69                        bool mult_db_connections,
  70                        bool disable_batch_insert)
  71 {
  72    /*
  73     * Initialize the parent class members.
  74     */
  75    m_db_interface_type = SQL_INTERFACE_TYPE_MYSQL;
  76    m_db_type = SQL_TYPE_MYSQL;
  77    m_db_driver = bstrdup("MySQL");
  78    m_db_name = bstrdup(db_name);
  79    m_db_user = bstrdup(db_user);
  80    if (db_password) {
  81       m_db_password = bstrdup(db_password);
  82    }
  83    if (db_address) {
  84       m_db_address = bstrdup(db_address);
  85    }
  86    if (db_socket) {
  87       m_db_socket = bstrdup(db_socket);
  88    }
  89    m_db_port = db_port;
  90
  91    if (disable_batch_insert) {
  92       m_disabled_batch_insert = true;
  93       m_have_batch_insert = false;
  94    } else {
  95       m_disabled_batch_insert = false;
  96 #if defined(USE_BATCH_FILE_INSERT)
  97 # if defined(HAVE_MYSQL_THREAD_SAFE)
  98       m_have_batch_insert = mysql_thread_safe();
  99 # else
 100       m_have_batch_insert = false;
 101 # endif /* HAVE_MYSQL_THREAD_SAFE */
 102 #else
 103       m_have_batch_insert = false;
 104 #endif /* USE_BATCH_FILE_INSERT */
 105    }
 106    errmsg = get_pool_memory(PM_EMSG); /* get error message buffer */
 107    *errmsg = 0;
 108    cmd = get_pool_memory(PM_EMSG);    /* get command buffer */
 109    cached_path = get_pool_memory(PM_FNAME);
 110    cached_path_id = 0;
 111    m_ref_count = 1;
 112    fname = get_pool_memory(PM_FNAME);
 113    path = get_pool_memory(PM_FNAME);
 114    esc_name = get_pool_memory(PM_FNAME);
 115    esc_path = get_pool_memory(PM_FNAME);
 116    esc_obj = get_pool_memory(PM_FNAME);
 117    m_allow_transactions = mult_db_connections;
 118
 119    /*
 120     * Initialize the private members.
 121     */
 122    m_db_handle = NULL;
 123    m_result = NULL;
 124
 125    /*
 126     * Put the db in the list.
 127     */
 128    if (db_list == NULL) {
 129       db_list = New(dlist(this, &this->m_link));
 130    }
 131    db_list->append(this);
 132 }
 133
 134 B_DB_MYSQL::~B_DB_MYSQL()
 135 {
 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 delete mdb here !!!!
 143  */
 144 bool B_DB_MYSQL::db_open_database(JCR *jcr)
 145 {
 146    bool retval = false;
 147    int errstat;
 148
 149    P(mutex);
 150    if (m_connected) {
 151       retval = true;
 152       goto bail_out;
 153    }
 154
 155    if ((errstat=rwl_init(&m_lock)) != 0) {
 156       berrno be;
 157       Mmsg1(&errmsg, _("Unable to initialize DB lock. ERR=%s\n"),
 158             be.bstrerror(errstat));
 159       goto bail_out;
 160    }
 161
 162    /*
 163     * Connect to the database
 164     */
 165 #ifdef xHAVE_EMBEDDED_MYSQL
 166 // mysql_server_init(0, NULL, NULL);
 167 #endif
 168    mysql_init(&m_instance);
 169
 170    Dmsg0(50, "mysql_init done\n");
 171    /*
 172     * If connection fails, try at 5 sec intervals for 30 seconds.
 173     */
 174    for (int retry=0; retry < 6; retry++) {
 175       m_db_handle = mysql_real_connect(
 176            &(m_instance),           /* db */
 177            m_db_address,            /* default = localhost */
 178            m_db_user,               /* login name */
 179            m_db_password,           /* password */
 180            m_db_name,               /* database name */
 181            m_db_port,               /* default port */
 182            m_db_socket,             /* default = socket */
 183            CLIENT_FOUND_ROWS);      /* flags */
 184
 185       /*
 186        * If no connect, try once more in case it is a timing problem
 187        */
 188       if (m_db_handle != NULL) {
 189          break;
 190       }
 191       bmicrosleep(5,0);
 192    }
 193
 194    m_instance.reconnect = 1;             /* so connection does not timeout */
 195    Dmsg0(50, "mysql_real_connect done\n");
 196    Dmsg3(50, "db_user=%s db_name=%s db_password=%s\n", m_db_user, m_db_name,
 197         (m_db_password == NULL) ? "(NULL)" : m_db_password);
 198
 199    if (m_db_handle == NULL) {
 200       Mmsg2(&errmsg, _("Unable to connect to MySQL server.\n"
 201 "Database=%s User=%s\n"
 202 "MySQL connect failed either server not running or your authorization is incorrect.\n"),
 203          m_db_name, m_db_user);
 204 #if MYSQL_VERSION_ID >= 40101
 205       Dmsg3(50, "Error %u (%s): %s\n",
 206             mysql_errno(&(m_instance)), mysql_sqlstate(&(m_instance)),
 207             mysql_error(&(m_instance)));
 208 #else
 209       Dmsg2(50, "Error %u: %s\n",
 210             mysql_errno(&(m_instance)), mysql_error(&(m_instance)));
 211 #endif
 212       goto bail_out;
 213    }
 214
 215    m_connected = true;
 216    if (!check_tables_version(jcr, this)) {
 217       goto bail_out;
 218    }
 219
 220    Dmsg3(100, "opendb ref=%d connected=%d db=%p\n", m_ref_count, m_connected, m_db_handle);
 221
 222    /*
 223     * Set connection timeout to 8 days specialy for batch mode
 224     */
 225    sql_query("SET wait_timeout=691200");
 226    sql_query("SET interactive_timeout=691200");
 227
 228    retval = true;
 229
 230 bail_out:
 231    V(mutex);
 232    return retval;
 233 }
 234
 235 void B_DB_MYSQL::db_close_database(JCR *jcr)
 236 {
 237    db_end_transaction(jcr);
 238    P(mutex);
 239    sql_free_result();
 240    m_ref_count--;
 241    Dmsg3(100, "closedb ref=%d connected=%d db=%p\n", m_ref_count, m_connected, m_db_handle);
 242    if (m_ref_count == 0) {
 243       db_list->remove(this);
 244       if (m_connected) {
 245          Dmsg1(100, "close db=%p\n", m_db_handle);
 246          mysql_close(&m_instance);
 247
 248 #ifdef xHAVE_EMBEDDED_MYSQL
 249 //       mysql_server_end();
 250 #endif
 251       }
 252       rwl_destroy(&m_lock);
 253       free_pool_memory(errmsg);
 254       free_pool_memory(cmd);
 255       free_pool_memory(cached_path);
 256       free_pool_memory(fname);
 257       free_pool_memory(path);
 258       free_pool_memory(esc_name);
 259       free_pool_memory(esc_path);
 260       free_pool_memory(esc_obj);
 261       if (m_db_driver) {
 262          free(m_db_driver);
 263       }
 264       if (m_db_name) {
 265          free(m_db_name);
 266       }
 267       if (m_db_user) {
 268          free(m_db_user);
 269       }
 270       if (m_db_password) {
 271          free(m_db_password);
 272       }
 273       if (m_db_address) {
 274          free(m_db_address);
 275       }
 276       if (m_db_socket) {
 277          free(m_db_socket);
 278       }
 279       delete this;
 280       if (db_list->size() == 0) {
 281          delete db_list;
 282          db_list = NULL;
 283       }
 284    }
 285    V(mutex);
 286 }
 287
 288 /*
 289  * This call is needed because the message channel thread
 290  *  opens a database on behalf of a jcr that was created in
 291  *  a different thread. MySQL then allocates thread specific
 292  *  data, which is NOT freed when the original jcr thread
 293  *  closes the database.  Thus the msgchan must call here
 294  *  to cleanup any thread specific data that it created.
 295  */
 296 void B_DB_MYSQL::db_thread_cleanup(void)
 297 {
 298 #ifndef HAVE_WIN32
 299    my_thread_end();
 300 #endif
 301 }
 302
 303 /*
 304  * Escape strings so that MySQL is happy
 305  *
 306  *   NOTE! len is the length of the old string. Your new
 307  *         string must be long enough (max 2*old+1) to hold
 308  *         the escaped output.
 309  */
 310 void B_DB_MYSQL::db_escape_string(JCR *jcr, char *snew, char *old, int len)
 311 {
 312    mysql_real_escape_string(m_db_handle, snew, old, len);
 313 }
 314
 315 /*
 316  * Escape binary object so that MySQL is happy
 317  * Memory is stored in B_DB struct, no need to free it
 318  */
 319 char *B_DB_MYSQL::db_escape_object(JCR *jcr, char *old, int len)
 320 {
 321    esc_obj = check_pool_memory_size(esc_obj, len*2+1);
 322    mysql_real_escape_string(m_db_handle, esc_obj, old, len);
 323    return esc_obj;
 324 }
 325
 326 /*
 327  * Unescape binary object so that MySQL is happy
 328  */
 329 void B_DB_MYSQL::db_unescape_object(JCR *jcr, char *from, int32_t expected_len,
 330                                     POOLMEM **dest, int32_t *dest_len)
 331 {
 332    if (!from) {
 333       *dest[0] = 0;
 334       *dest_len = 0;
 335       return;
 336    }
 337    *dest = check_pool_memory_size(*dest, expected_len+1);
 338    *dest_len = expected_len;
 339    memcpy(*dest, from, expected_len);
 340    (*dest)[expected_len]=0;
 341 }
 342
 343 void B_DB_MYSQL::db_start_transaction(JCR *jcr)
 344 {
 345    if (!jcr->attr) {
 346       jcr->attr = get_pool_memory(PM_FNAME);
 347    }
 348    if (!jcr->ar) {
 349       jcr->ar = (ATTR_DBR *)malloc(sizeof(ATTR_DBR));
 350    }
 351 }
 352
 353 void B_DB_MYSQL::db_end_transaction(JCR *jcr)
 354 {
 355    if (jcr && jcr->cached_attribute) {
 356       Dmsg0(400, "Flush last cached attribute.\n");
 357       if (!db_create_attributes_record(jcr, this, jcr->ar)) {
 358          Jmsg1(jcr, M_FATAL, 0, _("Attribute create error. %s"), db_strerror(jcr->db));
 359       }
 360       jcr->cached_attribute = false;
 361    }
 362 }
 363
 364 /*
 365  * Submit a general SQL command (cmd), and for each row returned,
 366  * the result_handler is called with the ctx.
 367  */
 368 bool B_DB_MYSQL::db_sql_query(const char *query, DB_RESULT_HANDLER *result_handler, void *ctx)
 369 {
 370    int ret;
 371    SQL_ROW row;
 372    bool send = true;
 373    bool retval = false;
 374
 375    Dmsg1(500, "db_sql_query starts with %s\n", query);
 376
 377    db_lock(this);
 378    ret = mysql_query(m_db_handle, query);
 379    if (ret != 0) {
 380       Mmsg(errmsg, _("Query failed: %s: ERR=%s\n"), query, sql_strerror());
 381       Dmsg0(500, "db_sql_query failed\n");
 382       goto bail_out;
 383    }
 384
 385    Dmsg0(500, "db_sql_query succeeded. checking handler\n");
 386
 387    if (result_handler != NULL) {
 388       if ((m_result = mysql_use_result(m_db_handle)) != NULL) {
 389          m_num_fields = mysql_num_fields(m_result);
 390
 391          /*
 392           * We *must* fetch all rows
 393           */
 394          while ((row = mysql_fetch_row(m_result)) != NULL) {
 395             if (send) {
 396                /* the result handler returns 1 when it has
 397                 *  seen all the data it wants.  However, we
 398                 *  loop to the end of the data.
 399                 */
 400                if (result_handler(ctx, m_num_fields, row)) {
 401                   send = false;
 402                }
 403             }
 404          }
 405          sql_free_result();
 406       }
 407    }
 408
 409    Dmsg0(500, "db_sql_query finished\n");
 410    retval = true;
 411
 412 bail_out:
 413    db_unlock(this);
 414    return retval;
 415 }
 416
 417 bool B_DB_MYSQL::sql_query(const char *query, int flags)
 418 {
 419    int ret;
 420    bool retval = true;
 421
 422    Dmsg1(500, "sql_query starts with '%s'\n", query);
 423    /*
 424     * We are starting a new query. reset everything.
 425     */
 426    m_num_rows     = -1;
 427    m_row_number   = -1;
 428    m_field_number = -1;
 429
 430    if (m_result) {
 431       mysql_free_result(m_result);
 432       m_result = NULL;
 433    }
 434
 435    ret = mysql_query(m_db_handle, query);
 436    if (ret == 0) {
 437       Dmsg0(500, "we have a result\n");
 438       if (flags & QF_STORE_RESULT) {
 439          m_result = mysql_store_result(m_db_handle);
 440          if (m_result != NULL) {
 441             m_num_fields = mysql_num_fields(m_result);
 442             Dmsg1(500, "we have %d fields\n", m_num_fields);
 443             m_num_rows = mysql_num_rows(m_result);
 444             Dmsg1(500, "we have %d rows\n", m_num_rows);
 445          } else {
 446             m_num_fields = 0;
 447             m_num_rows = mysql_affected_rows(m_db_handle);
 448             Dmsg1(500, "we have %d rows\n", m_num_rows);
 449          }
 450       } else {
 451          m_num_fields = 0;
 452          m_num_rows = mysql_affected_rows(m_db_handle);
 453          Dmsg1(500, "we have %d rows\n", m_num_rows);
 454       }
 455    } else {
 456       Dmsg0(500, "we failed\n");
 457       m_status = 1;                   /* failed */
 458       retval = false;
 459    }
 460    return retval;
 461 }
 462
 463 void B_DB_MYSQL::sql_free_result(void)
 464 {
 465    db_lock(this);
 466    if (m_result) {
 467       mysql_free_result(m_result);
 468       m_result = NULL;
 469    }
 470    if (m_fields) {
 471       free(m_fields);
 472       m_fields = NULL;
 473    }
 474    m_num_rows = m_num_fields = 0;
 475    db_unlock(this);
 476 }
 477
 478 SQL_ROW B_DB_MYSQL::sql_fetch_row(void)
 479 {
 480    if (!m_result) {
 481       return NULL;
 482    } else {
 483       return mysql_fetch_row(m_result);
 484    }
 485 }
 486
 487 const char *B_DB_MYSQL::sql_strerror(void)
 488 {
 489    return mysql_error(m_db_handle);
 490 }
 491
 492 void B_DB_MYSQL::sql_data_seek(int row)
 493 {
 494    return mysql_data_seek(m_result, row);
 495 }
 496
 497 int B_DB_MYSQL::sql_affected_rows(void)
 498 {
 499    return mysql_affected_rows(m_db_handle);
 500 }
 501
 502 uint64_t B_DB_MYSQL::sql_insert_autokey_record(const char *query, const char *table_name)
 503 {
 504    /*
 505     * First execute the insert query and then retrieve the currval.
 506     */
 507    if (mysql_query(m_db_handle, query) != 0) {
 508       return 0;
 509    }
 510
 511    m_num_rows = mysql_affected_rows(m_db_handle);
 512    if (m_num_rows != 1) {
 513       return 0;
 514    }
 515
 516    changes++;
 517
 518    return mysql_insert_id(m_db_handle);
 519 }
 520
 521 SQL_FIELD *B_DB_MYSQL::sql_fetch_field(void)
 522 {
 523    int i;
 524    MYSQL_FIELD *field;
 525
 526    if (!m_fields || m_fields_size < m_num_fields) {
 527       if (m_fields) {
 528          free(m_fields);
 529          m_fields = NULL;
 530       }
 531       Dmsg1(500, "allocating space for %d fields\n", m_num_fields);
 532       m_fields = (SQL_FIELD *)malloc(sizeof(SQL_FIELD) * m_num_fields);
 533       m_fields_size = m_num_fields;
 534
 535       for (i = 0; i < m_num_fields; i++) {
 536          Dmsg1(500, "filling field %d\n", i);
 537          if ((field = mysql_fetch_field(m_result)) != NULL) {
 538             m_fields[i].name = field->name;
 539             m_fields[i].max_length = field->max_length;
 540             m_fields[i].type = field->type;
 541             m_fields[i].flags = field->flags;
 542
 543             Dmsg4(500, "sql_fetch_field finds field '%s' has length='%d' type='%d' and IsNull=%d\n",
 544                   m_fields[i].name, m_fields[i].max_length, m_fields[i].type, m_fields[i].flags);
 545          }
 546       }
 547    }
 548
 549    /*
 550     * Increment field number for the next time around
 551     */
 552    return &m_fields[m_field_number++];
 553 }
 554
 555 bool B_DB_MYSQL::sql_field_is_not_null(int field_type)
 556 {
 557    return IS_NOT_NULL(field_type);
 558 }
 559
 560 bool B_DB_MYSQL::sql_field_is_numeric(int field_type)
 561 {
 562    return IS_NUM(field_type);
 563 }
 564
 565 /*
 566  * Returns true if OK
 567  *         false if failed
 568  */
 569 bool B_DB_MYSQL::sql_batch_start(JCR *jcr)
 570 {
 571    bool retval;
 572
 573    db_lock(this);
 574    retval = sql_query("CREATE TEMPORARY TABLE batch ("
 575                               "FileIndex integer,"
 576                               "JobId integer,"
 577                               "Path blob,"
 578                               "Name blob,"
 579                               "LStat tinyblob,"
 580                               "MD5 tinyblob,"
 581                               "DeltaSeq integer)");
 582    db_unlock(this);
 583
 584    return retval;
 585 }
 586
 587 /* set error to something to abort operation */
 588 /*
 589  * Returns true if OK
 590  *         false if failed
 591  */
 592 bool B_DB_MYSQL::sql_batch_end(JCR *jcr, const char *error)
 593 {
 594    m_status = 0;
 595
 596    return true;
 597 }
 598
 599 /*
 600  * Returns true if OK
 601  *         false if failed
 602  */
 603 bool B_DB_MYSQL::sql_batch_insert(JCR *jcr, ATTR_DBR *ar)
 604 {
 605    size_t len;
 606    const char *digest;
 607    char ed1[50];
 608
 609    esc_name = check_pool_memory_size(esc_name, fnl*2+1);
 610    db_escape_string(jcr, esc_name, fname, fnl);
 611
 612    esc_path = check_pool_memory_size(esc_path, pnl*2+1);
 613    db_escape_string(jcr, esc_path, path, pnl);
 614
 615    if (ar->Digest == NULL || ar->Digest[0] == 0) {
 616       digest = "0";
 617    } else {
 618       digest = ar->Digest;
 619    }
 620
 621    len = Mmsg(cmd, "INSERT INTO batch VALUES "
 622                    "(%u,%s,'%s','%s','%s','%s',%u)",
 623                    ar->FileIndex, edit_int64(ar->JobId,ed1), esc_path,
 624                    esc_name, ar->attr, digest, ar->DeltaSeq);
 625
 626    return sql_query(cmd);
 627 }
 628
 629 /*
 630  * Initialize database data structure. In principal this should
 631  * never have errors, or it is really fatal.
 632  */
 633 B_DB *db_init_database(JCR *jcr, const char *db_driver, const char *db_name, const char *db_user,
 634                        const char *db_password, const char *db_address, int db_port, const char *db_socket,
 635                        bool mult_db_connections, bool disable_batch_insert)
 636 {
 637    B_DB_MYSQL *mdb = NULL;
 638
 639    if (!db_user) {
 640       Jmsg(jcr, M_FATAL, 0, _("A user name for MySQL must be supplied.\n"));
 641       return NULL;
 642    }
 643    P(mutex);                          /* lock DB queue */
 644
 645    /*
 646     * Look to see if DB already open
 647     */
 648    if (db_list && !mult_db_connections) {
 649       foreach_dlist(mdb, db_list) {
 650          if (mdb->db_match_database(db_driver, db_name, db_address, db_port)) {
 651             Dmsg1(100, "DB REopen %s\n", db_name);
 652             mdb->increment_refcount();
 653             goto bail_out;
 654          }
 655       }
 656    }
 657    Dmsg0(100, "db_init_database first time\n");
 658    mdb = New(B_DB_MYSQL(jcr, db_driver, db_name, db_user, db_password, db_address,
 659                         db_port, db_socket, mult_db_connections, disable_batch_insert));
 660
 661 bail_out:
 662    V(mutex);
 663    return mdb;
 664 }
 665
 666 #endif /* HAVE_MYSQL */