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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2010 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 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 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  */
  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 #ifdef HAVE_MYSQL
  47
  48 /* -----------------------------------------------------------------------
  49  *
  50  *   MySQL dependent defines and subroutines
  51  *
  52  * -----------------------------------------------------------------------
  53  */
  54
  55 /* List of open databases */
  56 static dlist *db_list = NULL;
  57
  58 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  59
  60 /*
  61  * Retrieve database type
  62  */
  63 const char *
  64 db_get_type(void)
  65 {
  66    return "MySQL";
  67 }
  68
  69 /*
  70  * Initialize database data structure. In principal this should
  71  * never have errors, or it is really fatal.
  72  */
  73 B_DB *
  74 db_init_database(JCR *jcr, const char *db_name, const char *db_user, const char *db_password,
  75                  const char *db_address, int db_port, const char *db_socket,
  76                  int mult_db_connections)
  77 {
  78    B_DB *mdb = NULL;
  79
  80    if (!db_user) {
  81       Jmsg(jcr, M_FATAL, 0, _("A user name for MySQL must be supplied.\n"));
  82       return NULL;
  83    }
  84    P(mutex);                          /* lock DB queue */
  85    if (db_list == NULL) {
  86       db_list = New(dlist(mdb, &mdb->link));
  87    }
  88    /* Look to see if DB already open */
  89    if (!mult_db_connections) {
  90       foreach_dlist(mdb, db_list) {
  91          if (bstrcmp(mdb->db_name, db_name) &&
  92              bstrcmp(mdb->db_address, db_address) &&
  93              mdb->db_port == db_port) {
  94             Dmsg2(100, "DB REopen %d %s\n", mdb->ref_count, db_name);
  95             mdb->ref_count++;
  96             V(mutex);
  97             Dmsg3(100, "initdb ref=%d connected=%d db=%p\n", mdb->ref_count,
  98                   mdb->connected, mdb->db);
  99             return mdb;                  /* already open */
 100          }
 101       }
 102    }
 103    Dmsg0(100, "db_open first time\n");
 104    mdb = (B_DB *)malloc(sizeof(B_DB));
 105    memset(mdb, 0, sizeof(B_DB));
 106    mdb->db_name = bstrdup(db_name);
 107    mdb->db_user = bstrdup(db_user);
 108    if (db_password) {
 109       mdb->db_password = bstrdup(db_password);
 110    }
 111    if (db_address) {
 112       mdb->db_address = bstrdup(db_address);
 113    }
 114    if (db_socket) {
 115       mdb->db_socket = bstrdup(db_socket);
 116    }
 117    mdb->db_port = db_port;
 118    mdb->errmsg = get_pool_memory(PM_EMSG); /* get error message buffer */
 119    *mdb->errmsg = 0;
 120    mdb->cmd = get_pool_memory(PM_EMSG);    /* get command buffer */
 121    mdb->cached_path = get_pool_memory(PM_FNAME);
 122    mdb->cached_path_id = 0;
 123    mdb->ref_count = 1;
 124    mdb->fname = get_pool_memory(PM_FNAME);
 125    mdb->path = get_pool_memory(PM_FNAME);
 126    mdb->esc_name = get_pool_memory(PM_FNAME);
 127    mdb->esc_path = get_pool_memory(PM_FNAME);
 128    mdb->allow_transactions = mult_db_connections;
 129    db_list->append(mdb);                   /* put db in list */
 130    Dmsg3(100, "initdb ref=%d connected=%d db=%p\n", mdb->ref_count,
 131          mdb->connected, mdb->db);
 132    V(mutex);
 133    return mdb;
 134 }
 135
 136 /*
 137  * Now actually open the database.  This can generate errors,
 138  *  which are returned in the errmsg
 139  *
 140  * DO NOT close the database or free(mdb) here !!!!
 141  */
 142 int
 143 db_open_database(JCR *jcr, B_DB *mdb)
 144 {
 145    int errstat;
 146
 147    P(mutex);
 148    if (mdb->connected) {
 149       V(mutex);
 150       return 1;
 151    }
 152
 153    if ((errstat=rwl_init(&mdb->lock)) != 0) {
 154       berrno be;
 155       Mmsg1(&mdb->errmsg, _("Unable to initialize DB lock. ERR=%s\n"),
 156             be.bstrerror(errstat));
 157       V(mutex);
 158       return 0;
 159    }
 160
 161    /* connect to the database */
 162 #ifdef xHAVE_EMBEDDED_MYSQL
 163 // mysql_server_init(0, NULL, NULL);
 164 #endif
 165    mysql_init(&mdb->mysql);
 166
 167    Dmsg0(50, "mysql_init done\n");
 168    /* If connection fails, try at 5 sec intervals for 30 seconds. */
 169    for (int retry=0; retry < 6; retry++) {
 170       mdb->db = mysql_real_connect(
 171            &(mdb->mysql),                /* db */
 172            mdb->db_address,              /* default = localhost */
 173            mdb->db_user,                 /*  login name */
 174            mdb->db_password,             /*  password */
 175            mdb->db_name,                 /* database name */
 176            mdb->db_port,                 /* default port */
 177            mdb->db_socket,               /* default = socket */
 178            CLIENT_FOUND_ROWS);           /* flags */
 179
 180       /* If no connect, try once more in case it is a timing problem */
 181       if (mdb->db != NULL) {
 182          break;
 183       }
 184       bmicrosleep(5,0);
 185    }
 186
 187    mdb->mysql.reconnect = 1;             /* so connection does not timeout */
 188    Dmsg0(50, "mysql_real_connect done\n");
 189    Dmsg3(50, "db_user=%s db_name=%s db_password=%s\n", mdb->db_user, mdb->db_name,
 190             mdb->db_password==NULL?"(NULL)":mdb->db_password);
 191
 192    if (mdb->db == NULL) {
 193       Mmsg2(&mdb->errmsg, _("Unable to connect to MySQL server.\n"
 194 "Database=%s User=%s\n"
 195 "MySQL connect failed either server not running or your authorization is incorrect.\n"),
 196          mdb->db_name, mdb->db_user);
 197 #if MYSQL_VERSION_ID >= 40101
 198       Dmsg3(50, "Error %u (%s): %s\n",
 199             mysql_errno(&(mdb->mysql)), mysql_sqlstate(&(mdb->mysql)),
 200             mysql_error(&(mdb->mysql)));
 201 #else
 202       Dmsg2(50, "Error %u: %s\n",
 203             mysql_errno(&(mdb->mysql)), mysql_error(&(mdb->mysql)));
 204 #endif
 205       V(mutex);
 206       return 0;
 207    }
 208
 209    mdb->connected = true;
 210    if (!check_tables_version(jcr, mdb)) {
 211       V(mutex);
 212       return 0;
 213    }
 214
 215    Dmsg3(100, "opendb ref=%d connected=%d db=%p\n", mdb->ref_count,
 216          mdb->connected, mdb->db);
 217
 218    /* Set connection timeout to 8 days specialy for batch mode */
 219    sql_query(mdb, "SET wait_timeout=691200");
 220    sql_query(mdb, "SET interactive_timeout=691200");
 221
 222    V(mutex);
 223    return 1;
 224 }
 225
 226 void
 227 db_close_database(JCR *jcr, B_DB *mdb)
 228 {
 229    if (!mdb) {
 230       return;
 231    }
 232    db_end_transaction(jcr, mdb);
 233    P(mutex);
 234    sql_free_result(mdb);
 235    mdb->ref_count--;
 236    Dmsg3(100, "closedb ref=%d connected=%d db=%p\n", mdb->ref_count,
 237          mdb->connected, mdb->db);
 238    if (mdb->ref_count == 0) {
 239       db_list->remove(mdb);
 240       if (mdb->connected) {
 241          Dmsg1(100, "close db=%p\n", mdb->db);
 242          mysql_close(&mdb->mysql);
 243
 244 #ifdef xHAVE_EMBEDDED_MYSQL
 245 //       mysql_server_end();
 246 #endif
 247       }
 248       rwl_destroy(&mdb->lock);
 249       free_pool_memory(mdb->errmsg);
 250       free_pool_memory(mdb->cmd);
 251       free_pool_memory(mdb->cached_path);
 252       free_pool_memory(mdb->fname);
 253       free_pool_memory(mdb->path);
 254       free_pool_memory(mdb->esc_name);
 255       free_pool_memory(mdb->esc_path);
 256       if (mdb->db_name) {
 257          free(mdb->db_name);
 258       }
 259       if (mdb->db_user) {
 260          free(mdb->db_user);
 261       }
 262       if (mdb->db_password) {
 263          free(mdb->db_password);
 264       }
 265       if (mdb->db_address) {
 266          free(mdb->db_address);
 267       }
 268       if (mdb->db_socket) {
 269          free(mdb->db_socket);
 270       }
 271       free(mdb);
 272       if (db_list->size() == 0) {
 273          delete db_list;
 274          db_list = NULL;
 275       }
 276    }
 277    V(mutex);
 278 }
 279
 280 void db_check_backend_thread_safe()
 281 {
 282 #ifdef HAVE_BATCH_FILE_INSERT
 283    if (!mysql_thread_safe()) {
 284       Emsg0(M_ABORT, 0, _("MySQL client library must be thread-safe "
 285                           "when using BatchMode.\n"));
 286    }
 287 #endif
 288 }
 289
 290 /*
 291  * This call is needed because the message channel thread
 292  *  opens a database on behalf of a jcr that was created in
 293  *  a different thread. MySQL then allocates thread specific
 294  *  data, which is NOT freed when the original jcr thread
 295  *  closes the database.  Thus the msgchan must call here
 296  *  to cleanup any thread specific data that it created.
 297  */
 298 void db_thread_cleanup()
 299 {
 300 #ifndef HAVE_WIN32
 301    my_thread_end();
 302 #endif
 303 }
 304
 305 /*
 306  * Return the next unique index (auto-increment) for
 307  * the given table.  Return NULL on error.
 308  *
 309  * For MySQL, NULL causes the auto-increment value
 310  *  to be updated.
 311  */
 312 int db_next_index(JCR *jcr, B_DB *mdb, char *table, char *index)
 313 {
 314    strcpy(index, "NULL");
 315    return 1;
 316 }
 317
 318
 319 /*
 320  * Escape strings so that MySQL is happy
 321  *
 322  *   NOTE! len is the length of the old string. Your new
 323  *         string must be long enough (max 2*old+1) to hold
 324  *         the escaped output.
 325  */
 326 void
 327 db_escape_string(JCR *jcr, B_DB *mdb, char *snew, char *old, int len)
 328 {
 329    mysql_real_escape_string(mdb->db, snew, old, len);
 330 }
 331
 332 /*
 333  * Submit a general SQL command (cmd), and for each row returned,
 334  *  the sqlite_handler is called with the ctx.
 335  */
 336 bool db_sql_query(B_DB *mdb, const char *query, DB_RESULT_HANDLER *result_handler, void *ctx)
 337 {
 338    SQL_ROW row;
 339    bool send = true;
 340
 341    db_lock(mdb);
 342    if (sql_query(mdb, query) != 0) {
 343       Mmsg(mdb->errmsg, _("Query failed: %s: ERR=%s\n"), query, sql_strerror(mdb));
 344       db_unlock(mdb);
 345       return false;
 346    }
 347    if (result_handler != NULL) {
 348       if ((mdb->result = sql_use_result(mdb)) != NULL) {
 349          int num_fields = sql_num_fields(mdb);
 350
 351          /* We *must* fetch all rows */
 352          while ((row = sql_fetch_row(mdb)) != NULL) {
 353             if (send) {
 354                /* the result handler returns 1 when it has
 355                 *  seen all the data it wants.  However, we
 356                 *  loop to the end of the data.
 357                 */
 358                if (result_handler(ctx, num_fields, row)) {
 359                   send = false;
 360                }
 361             }
 362          }
 363
 364          sql_free_result(mdb);
 365       }
 366    }
 367    db_unlock(mdb);
 368    return true;
 369
 370 }
 371
 372 void my_mysql_free_result(B_DB *mdb)
 373 {
 374    db_lock(mdb);
 375    if (mdb->result) {
 376       mysql_free_result(mdb->result);
 377       mdb->result = NULL;
 378    }
 379    db_unlock(mdb);
 380 }
 381
 382 int my_mysql_insert_autokey_record(B_DB *mdb, const char *query, const char *table_name)
 383 {
 384    /*
 385     * First execute the insert query and then retrieve the currval.
 386     */
 387    if (mysql_query(mdb->db, query)) {
 388       return 0;
 389    }
 390
 391    mdb->num_rows = sql_affected_rows(mdb);
 392    if (mdb->num_rows != 1) {
 393       return 0;
 394    }
 395
 396    mdb->changes++;
 397
 398    return mysql_insert_id(mdb->db);
 399 }
 400
 401
 402 #ifdef HAVE_BATCH_FILE_INSERT
 403 const char *my_mysql_batch_lock_path_query =
 404    "LOCK TABLES Path write, batch write, Path as p write";
 405
 406
 407 const char *my_mysql_batch_lock_filename_query =
 408    "LOCK TABLES Filename write, batch write, Filename as f write";
 409
 410 const char *my_mysql_batch_unlock_tables_query = "UNLOCK TABLES";
 411
 412 const char *my_mysql_batch_fill_path_query =
 413    "INSERT INTO Path (Path) "
 414     "SELECT a.Path FROM "
 415      "(SELECT DISTINCT Path FROM batch) AS a WHERE NOT EXISTS "
 416      "(SELECT Path FROM Path AS p WHERE p.Path = a.Path)";
 417
 418 const char *my_mysql_batch_fill_filename_query =
 419    "INSERT INTO Filename (Name) "
 420     "SELECT a.Name FROM "
 421      "(SELECT DISTINCT Name FROM batch) AS a WHERE NOT EXISTS "
 422      "(SELECT Name FROM Filename AS f WHERE f.Name = a.Name)";
 423 #endif /* HAVE_BATCH_FILE_INSERT */
 424
 425 #endif /* HAVE_MYSQL */