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

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