~skinny.moey/drizzle/innodb-replication

#include <drizzled/session.h>

#include <drizzled/error.h>

#include <drizzled/gettext.h>

#include <drizzled/query_id.h>

#include <drizzled/data_home.h>

#include <drizzled/sql_base.h>

#include <drizzled/lock.h>

#include <drizzled/item/cache.h>

#include <drizzled/item/float.h>

#include <drizzled/item/return_int.h>

#include <drizzled/item/empty_string.h>

#include <drizzled/show.h>

#include <drizzled/plugin/client.h>

#include "drizzled/table_share_instance.h"

#include "boost/filesystem.hpp" 

  query(),

  global_read_lock(0),

  killed= NOT_KILLED;

  boost::mutex::scoped_lock scopedLock(mysys_var->mutex);

  killed= KILL_CONNECTION;

    unlock_global_read_lock(this);

void Session::awake(Session::killed_state state_to_set)

  killed= state_to_set;

    boost::mutex::scoped_lock scopedLock(mysys_var->mutex);

  while (! client->haveError() && killed != KILL_CONNECTION)

    if (! executeStatement())

  LOCK_thread_count.lock();

  getSessionList().push_back(this);

  LOCK_thread_count.unlock();

    killed= Session::KILL_CONNECTION;

const char* Session::enter_cond(boost::condition_variable &cond, boost::mutex &mutex, const char* msg)

  boost::mutex::scoped_lock scopedLock(mysys_var->mutex);

  lex_start(this);

bool Session::checkUser(const char *passwd, uint32_t passwd_len, const char *in_db)

  const string passwd_str(passwd, passwd_len);

  if (in_db && in_db[0])

  password= test(passwd_len);          // remember for error messages

  if (killed == KILL_CONNECTION)

    killed= Session::KILL_CONNECTION;

  for (std::vector<TableShareInstance *>::iterator iter= temporary_shares.begin();

       iter != temporary_shares.end(); iter++)

  {

    delete *iter;

  }

    (void) end_io_cache(cache);

    (void) internal::my_delete(path, MYF(0));           // Delete file on error

  int error= test(end_io_cache(cache));

    (void) end_io_cache(cache);

  path[0]= '\0';

  path[0]=0;

static int create_file(Session *session, char *path, file_exchange *exchange, internal::IO_CACHE *cache)

  uint32_t option= MY_UNPACK_FILENAME | MY_RELATIVE_PATH;

 

#ifdef DONT_ALLOW_FULL_LOAD_DATA_PATHS

  option|= MY_REPLACE_DIR;                      // Force use of db directory

#endif

 

  if (!internal::dirname_length(exchange->file_name))

    strcpy(path, getDataHomeCatalog().c_str());

    strncat(path, "/", 1);

    if (! session->db.empty())

      strncat(path, session->db.c_str(), FN_REFLEN-getDataHomeCatalog().size());

    (void) internal::fn_format(path, exchange->file_name, path, "", option);

    (void) internal::fn_format(path, exchange->file_name, getDataHomeCatalog().c_str(), "", option);

  if (opt_secure_file_priv)

    fs::path secure_file_path(fs::system_complete(fs::path(opt_secure_file_priv)));

    fs::path target_path(fs::system_complete(fs::path(path)));

    if (target_path.file_string().substr(0, secure_file_path.file_string().size()) != secure_file_path.file_string())

  if (!access(path, F_OK))

  if ((file= internal::my_create(path, 0666, O_WRONLY|O_EXCL, MYF(MY_WME))) < 0)

  if (init_io_cache(cache, file, 0L, internal::WRITE_CACHE, 0L, 1, MYF(MY_WME)))

    internal::my_delete(path, MYF(0));  // Delete file on error, it was just created

    strncpy(path,exchange->file_name,FN_REFLEN-1);