~drizzle-trunk/drizzle/development

/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-

 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:

 *

 *  Copyright (C) 2008 Sun Microsystems

 *

 *  This program is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation; version 2 of the License.

 *

 *  This program is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this program; if not, write to the Free Software

 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 */

#include "config.h"

#include <drizzled/configmake.h>

#include <drizzled/atomics.h>

#include <netdb.h>

#include <sys/types.h>

#include <netinet/tcp.h>

#include <netinet/in.h>

#include <signal.h>

#include <limits.h>

#include "drizzled/internal/my_sys.h"

#include "drizzled/internal/my_bit.h"

#include <drizzled/my_hash.h>

#include <drizzled/error.h>

#include <drizzled/errmsg_print.h>

#include <drizzled/tztime.h>

#include <drizzled/sql_base.h>

#include <drizzled/show.h>

#include <drizzled/sql_parse.h>

#include <drizzled/item/cmpfunc.h>

#include <drizzled/session.h>

#include <drizzled/item/create.h>

#include <drizzled/unireg.h>

#include "drizzled/temporal_format.h" /* For init_temporal_formats() */

#include "drizzled/plugin/listen.h"

#include "drizzled/plugin/error_message.h"

#include "drizzled/plugin/client.h"

#include "drizzled/plugin/scheduler.h"

#include "drizzled/plugin/xa_resource_manager.h"

#include "drizzled/plugin/monitored_in_transaction.h"

#include "drizzled/replication_services.h" /* For ReplicationServices::evaluateRegisteredPlugins() */

#include "drizzled/probes.h"

#include "drizzled/session_list.h"

#include "drizzled/charset.h"

#include "plugin/myisam/myisam.h"

#include "drizzled/drizzled.h"

#include <google/protobuf/stubs/common.h>

#if TIME_WITH_SYS_TIME

# include <sys/time.h>

# include <time.h>

#else

# if HAVE_SYS_TIME_H

#  include <sys/time.h>

# else

#  include <time.h>

# endif

#endif

#ifdef HAVE_SYS_PRCTL_H

#include <sys/prctl.h>

#endif

#include <sys/socket.h>

#include <errno.h>

#include <sys/stat.h>

#include "drizzled/option.h"

#ifdef HAVE_SYSENT_H

#include <sysent.h>

#endif

#include <pwd.h>				// For getpwent

#include <grp.h>

#ifdef HAVE_SELECT_H

#  include <select.h>

#endif

#ifdef HAVE_SYS_SELECT_H

#include <sys/select.h>

#endif

#include <sys/utsname.h>

#ifdef HAVE_SYS_MMAN_H

#include <sys/mman.h>

#endif

#if defined(__FreeBSD__) && defined(HAVE_IEEEFP_H)

#include <ieeefp.h>

#endif /* __FreeBSD__ && HAVE_IEEEFP_H */

#ifdef HAVE_FPU_CONTROL_H

#include <fpu_control.h>

#endif

#ifdef HAVE_SYS_FPU_H

/* for IRIX to use set_fpc_csr() */

#include <sys/fpu.h>

#endif

#include "drizzled/internal/my_pthread.h"			// For thr_setconcurency()

#include <drizzled/gettext.h>

#ifdef HAVE_purify

#define IF_PURIFY(A,B) (A)

#else

#define IF_PURIFY(A,B) (B)

#endif

#define MAX_MEM_TABLE_SIZE SIZE_MAX

using namespace std;

namespace drizzled

{

#define mysqld_charset &my_charset_utf8_general_ci

inline void setup_fpu()

{

#if defined(__FreeBSD__) && defined(HAVE_IEEEFP_H)

  /*

     We can't handle floating point exceptions with threads, so disable

     this on freebsd.

     Don't fall for overflow, underflow,divide-by-zero or loss of precision

  */

#if defined(__i386__)

  fpsetmask(~(FP_X_INV | FP_X_DNML | FP_X_OFL | FP_X_UFL | FP_X_DZ |

	      FP_X_IMP));

#else

  fpsetmask(~(FP_X_INV |             FP_X_OFL | FP_X_UFL | FP_X_DZ |

              FP_X_IMP));

#endif /* __i386__ */

#endif /* __FreeBSD__ && HAVE_IEEEFP_H */

  /*

    x86 (32-bit) requires FPU precision to be explicitly set to 64 bit for

    portable results of floating point operations

  */

#if defined(__i386__) && defined(HAVE_FPU_CONTROL_H) && defined(_FPU_DOUBLE)

  fpu_control_t cw;

  _FPU_GETCW(cw);

  cw= (cw & ~_FPU_EXTENDED) | _FPU_DOUBLE;

  _FPU_SETCW(cw);

#endif /* __i386__ && HAVE_FPU_CONTROL_H && _FPU_DOUBLE */

}

#ifdef SOLARIS

extern "C" int gethostname(char *name, int namelen);

#endif

/* Constants */

static const char *tc_heuristic_recover_names[]=

{

  "COMMIT", "ROLLBACK", NULL

};

static TYPELIB tc_heuristic_recover_typelib=

{

  array_elements(tc_heuristic_recover_names)-1,"",

  tc_heuristic_recover_names, NULL

};

const char *first_keyword= "first";

const char * const DRIZZLE_CONFIG_NAME= "drizzled";

#define GET_HA_ROWS GET_ULL

const char *tx_isolation_names[] =

{ "READ-UNCOMMITTED", "READ-COMMITTED", "REPEATABLE-READ", "SERIALIZABLE",

  NULL};

TYPELIB tx_isolation_typelib= {array_elements(tx_isolation_names)-1,"",

                               tx_isolation_names, NULL};

/*

  Used with --help for detailed option

*/

bool opt_help= false;

bool opt_help_extended= false;

arg_cmp_func Arg_comparator::comparator_matrix[5][2] =

{{&Arg_comparator::compare_string,     &Arg_comparator::compare_e_string},

 {&Arg_comparator::compare_real,       &Arg_comparator::compare_e_real},

 {&Arg_comparator::compare_int_signed, &Arg_comparator::compare_e_int},

 {&Arg_comparator::compare_row,        &Arg_comparator::compare_e_row},

 {&Arg_comparator::compare_decimal,    &Arg_comparator::compare_e_decimal}};

/* static variables */

static bool opt_debugging= 0;

static uint32_t wake_thread;

static char *drizzled_chroot;

static char *language_ptr;

static const char *default_character_set_name;

static const char *character_set_filesystem_name;

static char *lc_time_names_name;

static char *default_collation_name;

static char *default_storage_engine_str;

static const char *compiled_default_collation_name= "utf8_general_ci";

/* Global variables */

bool volatile ready_to_exit;

char *drizzled_user;

bool volatile select_thread_in_use;

bool volatile abort_loop;

bool volatile shutdown_in_progress;

uint32_t max_used_connections;

const string opt_scheduler_default("multi_thread");

char *opt_scheduler= NULL;

size_t my_thread_stack_size= 65536;

/*

  Legacy global plugin::StorageEngine. These will be removed (please do not add more).

*/

plugin::StorageEngine *heap_engine;

plugin::StorageEngine *myisam_engine;

char* opt_secure_file_priv= 0;

bool calling_initgroups= false; /**< Used in SIGSEGV handler. */

uint32_t drizzled_bind_timeout;

std::bitset<12> test_flags;

uint32_t dropping_tables, ha_open_options;

uint32_t tc_heuristic_recover= 0;

uint64_t session_startup_options;

uint32_t back_log;

uint32_t server_id;

uint64_t table_cache_size;

size_t table_def_size;

uint64_t aborted_threads;

uint64_t aborted_connects;

uint64_t max_connect_errors;

uint32_t global_thread_id= 1UL;

pid_t current_pid;

extern const double log_10[309];

const double log_10[] = {

  1e000, 1e001, 1e002, 1e003, 1e004, 1e005, 1e006, 1e007, 1e008, 1e009,

  1e010, 1e011, 1e012, 1e013, 1e014, 1e015, 1e016, 1e017, 1e018, 1e019,

  1e020, 1e021, 1e022, 1e023, 1e024, 1e025, 1e026, 1e027, 1e028, 1e029,

  1e030, 1e031, 1e032, 1e033, 1e034, 1e035, 1e036, 1e037, 1e038, 1e039,

  1e040, 1e041, 1e042, 1e043, 1e044, 1e045, 1e046, 1e047, 1e048, 1e049,

  1e050, 1e051, 1e052, 1e053, 1e054, 1e055, 1e056, 1e057, 1e058, 1e059,

  1e060, 1e061, 1e062, 1e063, 1e064, 1e065, 1e066, 1e067, 1e068, 1e069,

  1e070, 1e071, 1e072, 1e073, 1e074, 1e075, 1e076, 1e077, 1e078, 1e079,

  1e080, 1e081, 1e082, 1e083, 1e084, 1e085, 1e086, 1e087, 1e088, 1e089,

  1e090, 1e091, 1e092, 1e093, 1e094, 1e095, 1e096, 1e097, 1e098, 1e099,

  1e100, 1e101, 1e102, 1e103, 1e104, 1e105, 1e106, 1e107, 1e108, 1e109,

  1e110, 1e111, 1e112, 1e113, 1e114, 1e115, 1e116, 1e117, 1e118, 1e119,

  1e120, 1e121, 1e122, 1e123, 1e124, 1e125, 1e126, 1e127, 1e128, 1e129,

  1e130, 1e131, 1e132, 1e133, 1e134, 1e135, 1e136, 1e137, 1e138, 1e139,

  1e140, 1e141, 1e142, 1e143, 1e144, 1e145, 1e146, 1e147, 1e148, 1e149,

  1e150, 1e151, 1e152, 1e153, 1e154, 1e155, 1e156, 1e157, 1e158, 1e159,

  1e160, 1e161, 1e162, 1e163, 1e164, 1e165, 1e166, 1e167, 1e168, 1e169,

  1e170, 1e171, 1e172, 1e173, 1e174, 1e175, 1e176, 1e177, 1e178, 1e179,

  1e180, 1e181, 1e182, 1e183, 1e184, 1e185, 1e186, 1e187, 1e188, 1e189,

  1e190, 1e191, 1e192, 1e193, 1e194, 1e195, 1e196, 1e197, 1e198, 1e199,

  1e200, 1e201, 1e202, 1e203, 1e204, 1e205, 1e206, 1e207, 1e208, 1e209,

  1e210, 1e211, 1e212, 1e213, 1e214, 1e215, 1e216, 1e217, 1e218, 1e219,

  1e220, 1e221, 1e222, 1e223, 1e224, 1e225, 1e226, 1e227, 1e228, 1e229,

  1e230, 1e231, 1e232, 1e233, 1e234, 1e235, 1e236, 1e237, 1e238, 1e239,

  1e240, 1e241, 1e242, 1e243, 1e244, 1e245, 1e246, 1e247, 1e248, 1e249,

  1e250, 1e251, 1e252, 1e253, 1e254, 1e255, 1e256, 1e257, 1e258, 1e259,

  1e260, 1e261, 1e262, 1e263, 1e264, 1e265, 1e266, 1e267, 1e268, 1e269,

  1e270, 1e271, 1e272, 1e273, 1e274, 1e275, 1e276, 1e277, 1e278, 1e279,

  1e280, 1e281, 1e282, 1e283, 1e284, 1e285, 1e286, 1e287, 1e288, 1e289,

  1e290, 1e291, 1e292, 1e293, 1e294, 1e295, 1e296, 1e297, 1e298, 1e299,

  1e300, 1e301, 1e302, 1e303, 1e304, 1e305, 1e306, 1e307, 1e308

};

time_t server_start_time;

time_t flush_status_time;

char drizzle_home[FN_REFLEN], pidfile_name[FN_REFLEN], system_time_zone[30];

char *default_tz_name;

char glob_hostname[FN_REFLEN];

char data_home_real[FN_REFLEN],

     language[FN_REFLEN], 

     *opt_tc_log_file;

char data_home_real_unpacked[FN_REFLEN];

const key_map key_map_empty(0);

key_map key_map_full(0);                        // Will be initialized later

uint32_t data_home_len;

char data_home_buff[2], *data_home=data_home_real;

char *drizzle_tmpdir= NULL;

char *opt_drizzle_tmpdir= NULL;

/** name of reference on left espression in rewritten IN subquery */

const char *in_left_expr_name= "<left expr>";

/** name of additional condition */

const char *in_additional_cond= "<IN COND>";

const char *in_having_cond= "<IN HAVING>";

my_decimal decimal_zero;

/* classes for comparation parsing/processing */

FILE *stderror_file=0;

struct system_variables global_system_variables;

struct system_variables max_system_variables;

struct system_status_var global_status_var;

const CHARSET_INFO *system_charset_info, *files_charset_info ;

const CHARSET_INFO *table_alias_charset;

const CHARSET_INFO *character_set_filesystem;

MY_LOCALE *my_default_lc_time_names;

SHOW_COMP_OPTION have_symlink;

/* Thread specific variables */

pthread_key_t THR_Mem_root;

pthread_key_t THR_Session;

pthread_mutex_t LOCK_create_db;

pthread_mutex_t LOCK_open;

pthread_mutex_t LOCK_thread_count;

pthread_mutex_t LOCK_status;

pthread_mutex_t LOCK_global_read_lock;

pthread_mutex_t LOCK_global_system_variables;

pthread_rwlock_t	LOCK_system_variables_hash;

pthread_cond_t COND_refresh, COND_thread_count, COND_global_read_lock;

pthread_t signal_thread;

pthread_cond_t  COND_server_end;

/* Static variables */

int cleanup_done;

static char *drizzle_home_ptr, *pidfile_name_ptr;

static int defaults_argc;

static char **defaults_argv;

passwd *user_info;

/**

  Number of currently active user connections. The variable is protected by

  LOCK_thread_count.

*/

atomic<uint32_t> connection_count;

/** 

  Refresh value. We use to test this to find out if a refresh even has happened recently.

*/

uint64_t refresh_version;  /* Increments on each reload */

/* Function declarations */

bool drizzle_rm_tmp_tables();

static void drizzle_init_variables(void);

static void get_options(int *argc,char **argv);

int drizzled_get_one_option(int, const struct option *, char *);

static int init_thread_environment();

static const char *get_relative_path(const char *path);

static void fix_paths(string &progname);

static void usage(void);

void close_connections(void);

/****************************************************************************

** Code to end drizzled

****************************************************************************/

void close_connections(void)

{

  /* Abort listening to new connections */

  plugin::Listen::shutdown();

  /* kill connection thread */

  (void) pthread_mutex_lock(&LOCK_thread_count);

  while (select_thread_in_use)

  {

    struct timespec abstime;

    int error;

    set_timespec(abstime, 2);

    for (uint32_t tmp=0 ; tmp < 10 && select_thread_in_use; tmp++)

    {

      error=pthread_cond_timedwait(&COND_thread_count,&LOCK_thread_count, &abstime);

      if (error != EINTR)

        break;

    }

  }

  (void) pthread_mutex_unlock(&LOCK_thread_count);

  /*

    First signal all threads that it's time to die

    This will give the threads some time to gracefully abort their

    statements and inform their clients that the server is about to die.

  */

  Session *tmp;

  (void) pthread_mutex_lock(&LOCK_thread_count); // For unlink from list

  for( SessionList::iterator it= getSessionList().begin(); it != getSessionList().end(); ++it )

  {

    tmp= *it;

    tmp->killed= Session::KILL_CONNECTION;

    tmp->scheduler->killSession(tmp);

    DRIZZLE_CONNECTION_DONE(tmp->thread_id);

    if (tmp->mysys_var)

    {

      tmp->mysys_var->abort=1;

      pthread_mutex_lock(&tmp->mysys_var->mutex);

      if (tmp->mysys_var->current_cond)

      {

        pthread_mutex_lock(tmp->mysys_var->current_mutex);

        pthread_cond_broadcast(tmp->mysys_var->current_cond);

        pthread_mutex_unlock(tmp->mysys_var->current_mutex);

      }

      pthread_mutex_unlock(&tmp->mysys_var->mutex);

    }

  }

  (void) pthread_mutex_unlock(&LOCK_thread_count); // For unlink from list

  if (connection_count)

    sleep(2);                                   // Give threads time to die

  /*

    Force remaining threads to die by closing the connection to the client

    This will ensure that threads that are waiting for a command from the

    client on a blocking read call are aborted.

  */

  for (;;)

  {

    (void) pthread_mutex_lock(&LOCK_thread_count); // For unlink from list

    if (getSessionList().empty())

    {

      (void) pthread_mutex_unlock(&LOCK_thread_count);

      break;

    }

    tmp= getSessionList().front();

    /* Close before unlock, avoiding crash. See LP bug#436685 */

    tmp->client->close();

    (void) pthread_mutex_unlock(&LOCK_thread_count);

  }

}

/**

  cleanup all memory and end program nicely.

    If SIGNALS_DONT_BREAK_READ is defined, this function is called

    by the main thread. To get Drizzle to shut down nicely in this case

    (Mac OS X) we have to call exit() instead if pthread_exit().

  @note

    This function never returns.

*/

void unireg_end(void)

{

  clean_up(1);

  internal::my_thread_end();

#if defined(SIGNALS_DONT_BREAK_READ)

  exit(0);

#else

  pthread_exit(0);				// Exit is in main thread

#endif

}

void unireg_abort(int exit_code)

{

  if (exit_code)

    errmsg_printf(ERRMSG_LVL_ERROR, _("Aborting\n"));

  else if (opt_help || opt_help_extended)

    usage();

  clean_up(!opt_help && (exit_code));

  clean_up_mutexes();

  internal::my_end();

  exit(exit_code);

}

void clean_up(bool print_message)

{

  if (cleanup_done++)

    return;

  table_cache_free();

  TableShare::cacheStop();

  set_var_free();

  free_charsets();

  plugin::Registry &plugins= plugin::Registry::singleton();

  plugin_shutdown(plugins);

  xid_cache_free();

  free_status_vars();

  if (defaults_argv)

    internal::free_defaults(defaults_argv);

  free(drizzle_tmpdir);

  if (opt_secure_file_priv)

    free(opt_secure_file_priv);

  deinit_temporal_formats();

#if GOOGLE_PROTOBUF_VERSION >= 2001000

  google::protobuf::ShutdownProtobufLibrary();

#endif

  (void) unlink(pidfile_name);	// This may not always exist

  if (print_message && server_start_time)

    errmsg_printf(ERRMSG_LVL_INFO, _(ER(ER_SHUTDOWN_COMPLETE)),internal::my_progname);

  (void) pthread_mutex_lock(&LOCK_thread_count);

  ready_to_exit=1;

  /* do the broadcast inside the lock to ensure that my_end() is not called */

  (void) pthread_cond_broadcast(&COND_server_end);

  (void) pthread_mutex_unlock(&LOCK_thread_count);

  /*

    The following lines may never be executed as the main thread may have

    killed us

  */

} /* clean_up */

void clean_up_mutexes()

{

  (void) pthread_mutex_destroy(&LOCK_create_db);

  (void) pthread_mutex_destroy(&LOCK_open);

  (void) pthread_mutex_destroy(&LOCK_thread_count);

  (void) pthread_mutex_destroy(&LOCK_status);

  (void) pthread_mutex_destroy(&LOCK_global_system_variables);

  (void) pthread_rwlock_destroy(&LOCK_system_variables_hash);

  (void) pthread_mutex_destroy(&LOCK_global_read_lock);

  (void) pthread_cond_destroy(&COND_thread_count);

  (void) pthread_cond_destroy(&COND_server_end);

  (void) pthread_cond_destroy(&COND_refresh);

  (void) pthread_cond_destroy(&COND_global_read_lock);

}

/* Change to run as another user if started with --user */

passwd *check_user(const char *user)

{

  passwd *tmp_user_info;

  uid_t user_id= geteuid();

  // Don't bother if we aren't superuser

  if (user_id)

  {

    if (user)

    {

      /* Don't give a warning, if real user is same as given with --user */

      tmp_user_info= getpwnam(user);

      if ((!tmp_user_info || user_id != tmp_user_info->pw_uid) &&

          global_system_variables.log_warnings)

            errmsg_printf(ERRMSG_LVL_WARN, _("One can only use the --user switch "

                            "if running as root\n"));

    }

    return NULL;

  }

  if (!user)

  {

      errmsg_printf(ERRMSG_LVL_ERROR, _("Fatal error: Please read \"Security\" section of "

                      "the manual to find out how to run drizzled as root!\n"));

    unireg_abort(1);

  }

  if (!strcmp(user,"root"))

    return NULL;                        // Avoid problem with dynamic libraries

  if (!(tmp_user_info= getpwnam(user)))

  {

    // Allow a numeric uid to be used

    const char *pos;

    for (pos= user; my_isdigit(mysqld_charset,*pos); pos++) ;

    if (*pos)                                   // Not numeric id

      goto err;

    if (!(tmp_user_info= getpwuid(atoi(user))))

      goto err;

  }

  return tmp_user_info;

err:

  errmsg_printf(ERRMSG_LVL_ERROR, _("Fatal error: Can't change to run as user '%s' ;  "

                    "Please check that the user exists!\n"),user);

  unireg_abort(1);

#ifdef PR_SET_DUMPABLE

  if (test_flags.test(TEST_CORE_ON_SIGNAL))

  {

    /* inform kernel that process is dumpable */

    (void) prctl(PR_SET_DUMPABLE, 1);

  }

#endif

/* Sun Studio 5.10 doesn't like this line.  5.9 requires it */

#if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x590)

  return NULL;

#endif

}

void set_user(const char *user, passwd *user_info_arg)

{

  assert(user_info_arg != 0);

  /*

    We can get a SIGSEGV when calling initgroups() on some systems when NSS

    is configured to use LDAP and the server is statically linked.  We set

    calling_initgroups as a flag to the SIGSEGV handler that is then used to

    output a specific message to help the user resolve this problem.

  */

  calling_initgroups= true;

  initgroups((char*) user, user_info_arg->pw_gid);

  calling_initgroups= false;

  if (setgid(user_info_arg->pw_gid) == -1)

  {

    sql_perror("setgid");

    unireg_abort(1);

  }

  if (setuid(user_info_arg->pw_uid) == -1)

  {

    sql_perror("setuid");

    unireg_abort(1);

  }

}

/** Change root user if started with @c --chroot . */

static void set_root(const char *path)

{

  if ((chroot(path) == -1) || !chdir("/"))

  {

    sql_perror("chroot");

    unireg_abort(1);

  }

}

/*

  Unlink session from global list of available connections and free session

  SYNOPSIS

    Session::unlink()

    session		 Thread handler

  NOTES

    LOCK_thread_count is locked and left locked

*/

void Session::unlink(Session *session)

{

  connection_count.decrement();

  session->cleanup();

  (void) pthread_mutex_lock(&LOCK_thread_count);

  pthread_mutex_lock(&session->LOCK_delete);