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