~drizzle-trunk/drizzle/development

/* Copyright (C) 2005 MySQL AB

   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

#include <drizzled/server_includes.h>

#include <mysys/my_getopt.h>

#include <authentication.h>

#include <logging.h>

#include <drizzled/drizzled_error_messages.h>

#define REPORT_TO_LOG  1

#define REPORT_TO_USER 2

#define plugin_ref_to_int(A) (A ? A[0] : NULL)

#define plugin_int_to_ref(A) &(A)

extern struct st_mysql_plugin *mysqld_builtins[];

char *opt_plugin_load= NULL;

char *opt_plugin_dir_ptr;

char opt_plugin_dir[FN_REFLEN];

/*

  When you ad a new plugin type, add both a string and make sure that the

  init and deinit array are correctly updated.

*/

const LEX_STRING plugin_type_names[DRIZZLE_MAX_PLUGIN_TYPE_NUM]=

{

  { C_STRING_WITH_LEN("DAEMON") },

  { C_STRING_WITH_LEN("STORAGE ENGINE") },

  { C_STRING_WITH_LEN("INFORMATION SCHEMA") },

  { C_STRING_WITH_LEN("UDF") },

  { C_STRING_WITH_LEN("UDA") },

  { C_STRING_WITH_LEN("AUDIT") },

  { C_STRING_WITH_LEN("LOGGER") },

  { C_STRING_WITH_LEN("AUTH") }

};

extern int initialize_schema_table(st_plugin_int *plugin);

extern int finalize_schema_table(st_plugin_int *plugin);

extern int initialize_udf(st_plugin_int *plugin);

extern int finalize_udf(st_plugin_int *plugin);

/*

  The number of elements in both plugin_type_initialize and

  plugin_type_deinitialize should equal to the number of plugins

  defined.

*/

plugin_type_init plugin_type_initialize[DRIZZLE_MAX_PLUGIN_TYPE_NUM]=

{

  0,  /* Daemon */

  ha_initialize_handlerton,  /* Storage Engine */

  initialize_schema_table,  /* Information Schema */

  initialize_udf,  /* UDF */

  0,  /* UDA */

  0,  /* Audit */

  logging_initializer,  /* Logger */

  authentication_initializer  /* Auth */

};

plugin_type_init plugin_type_deinitialize[DRIZZLE_MAX_PLUGIN_TYPE_NUM]=

{

  0,  /* Daemon */

  ha_finalize_handlerton,  /* Storage Engine */

  finalize_schema_table,  /* Information Schema */

  finalize_udf,  /* UDF */

  0,  /* UDA */

  0,  /* Audit */

  logging_finalizer,  /* Logger */

  authentication_finalizer  /* Auth */

};

static const char *plugin_declarations_sym= "_mysql_plugin_declarations_";

/* Note that 'int version' must be the first field of every plugin

   sub-structure (plugin->info).

*/

static bool initialized= 0;

static DYNAMIC_ARRAY plugin_dl_array;

static DYNAMIC_ARRAY plugin_array;

static HASH plugin_hash[DRIZZLE_MAX_PLUGIN_TYPE_NUM];

static bool reap_needed= false;

static int plugin_array_version=0;

/*

  write-lock on LOCK_system_variables_hash is required before modifying

  the following variables/structures

*/

static MEM_ROOT plugin_mem_root;

static uint32_t global_variables_dynamic_size= 0;

static HASH bookmark_hash;

/*

  hidden part of opaque value passed to variable check functions.

  Used to provide a object-like structure to non C++ consumers.

*/

struct st_item_value_holder : public st_mysql_value

{

  Item *item;

};

/*

  stored in bookmark_hash, this structure is never removed from the

  hash and is used to mark a single offset for a thd local variable

  even if plugins have been uninstalled and reinstalled, repeatedly.

  This structure is allocated from plugin_mem_root.

  The key format is as follows:

    1 byte         - variable type code

    name_len bytes - variable name

    '\0'           - end of key

*/

struct st_bookmark

{

  uint32_t name_len;

  int offset;

  uint32_t version;

  char key[1];

};

/*

  skeleton of a plugin variable - portion of structure common to all.

*/

struct st_mysql_sys_var

{

  DRIZZLE_PLUGIN_VAR_HEADER;

};

/*

  sys_var class for access to all plugin variables visible to the user

*/

class sys_var_pluginvar: public sys_var

{

public:

  struct st_plugin_int *plugin;

  struct st_mysql_sys_var *plugin_var;

  static void *operator new(size_t size, MEM_ROOT *mem_root)

  { return (void*) alloc_root(mem_root, (uint) size); }

  static void operator delete(void *ptr_arg __attribute__((unused)),

                              size_t size __attribute__((unused)))

  { TRASH(ptr_arg, size); }

  sys_var_pluginvar(const char *name_arg,

                    struct st_mysql_sys_var *plugin_var_arg)

    :sys_var(name_arg), plugin_var(plugin_var_arg) {}

  sys_var_pluginvar *cast_pluginvar() { return this; }

  bool is_readonly() const { return plugin_var->flags & PLUGIN_VAR_READONLY; }

  bool check_type(enum_var_type type)

  { return !(plugin_var->flags & PLUGIN_VAR_THDLOCAL) && type != OPT_GLOBAL; }

  bool check_update_type(Item_result type);

  SHOW_TYPE show_type();

  unsigned char* real_value_ptr(THD *thd, enum_var_type type);

  TYPELIB* plugin_var_typelib(void);

  unsigned char* value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);

  bool check(THD *thd, set_var *var);

  bool check_default(enum_var_type type __attribute__((unused)))

    { return is_readonly(); }

  void set_default(THD *thd,

                   enum_var_type type __attribute__((unused)));

  bool update(THD *thd, set_var *var);

};

/* prototypes */

static bool plugin_load_list(MEM_ROOT *tmp_root, int *argc, char **argv,

                             const char *list);

static int test_plugin_options(MEM_ROOT *, struct st_plugin_int *,

                               int *, char **);

static bool register_builtin(struct st_mysql_plugin *, struct st_plugin_int *,

                             struct st_plugin_int **);

static void unlock_variables(THD *thd, struct system_variables *vars);

static void cleanup_variables(THD *thd, struct system_variables *vars);

static void plugin_vars_free_values(sys_var *vars);

static void plugin_opt_set_limits(struct my_option *options,

                                  const struct st_mysql_sys_var *opt);

#define my_intern_plugin_lock(A,B) intern_plugin_lock(A,B CALLER_INFO)

#define my_intern_plugin_lock_ci(A,B) intern_plugin_lock(A,B ORIG_CALLER_INFO)

static plugin_ref intern_plugin_lock(LEX *lex, plugin_ref plugin

                                     CALLER_INFO_PROTO);

static void intern_plugin_unlock(LEX *lex, plugin_ref plugin);

static void reap_plugins(void);

/* declared in set_var.cc */

extern sys_var *intern_find_sys_var(const char *str, uint32_t length, bool no_error);

extern bool throw_bounds_warning(THD *thd, bool fixed, bool unsignd,

                                 const char *name, int64_t val);

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

  Value type thunks, allows the C world to play in the C++ world

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

static int item_value_type(struct st_mysql_value *value)

{

  switch (((st_item_value_holder*)value)->item->result_type()) {

  case INT_RESULT:

    return DRIZZLE_VALUE_TYPE_INT;

  case REAL_RESULT:

    return DRIZZLE_VALUE_TYPE_REAL;

  default:

    return DRIZZLE_VALUE_TYPE_STRING;

  }

}

static const char *item_val_str(struct st_mysql_value *value,

                                char *buffer, int *length)

{

  String str(buffer, *length, system_charset_info), *res;

  if (!(res= ((st_item_value_holder*)value)->item->val_str(&str)))

    return NULL;

  *length= res->length();

  if (res->c_ptr_quick() == buffer)

    return buffer;

  /*

    Lets be nice and create a temporary string since the

    buffer was too small

  */

  return current_thd->strmake(res->c_ptr_quick(), res->length());

}

static int item_val_int(struct st_mysql_value *value, int64_t *buf)

{

  Item *item= ((st_item_value_holder*)value)->item;

  *buf= item->val_int();

  if (item->is_null())

    return 1;

  return 0;

}

static int item_val_real(struct st_mysql_value *value, double *buf)

{

  Item *item= ((st_item_value_holder*)value)->item;

  *buf= item->val_real();

  if (item->is_null())

    return 1;

  return 0;

}

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

  Plugin support code

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

static struct st_plugin_dl *plugin_dl_find(const LEX_STRING *dl)

{

  uint32_t i;

  struct st_plugin_dl *tmp;

  for (i= 0; i < plugin_dl_array.elements; i++)

  {

    tmp= *dynamic_element(&plugin_dl_array, i, struct st_plugin_dl **);

    if (tmp->ref_count &&

        ! my_strnncoll(files_charset_info,

                       (const unsigned char *)dl->str, dl->length,

                       (const unsigned char *)tmp->dl.str, tmp->dl.length))

      return(tmp);

  }

  return(0);

}

static st_plugin_dl *plugin_dl_insert_or_reuse(struct st_plugin_dl *plugin_dl)

{

  uint32_t i;

  struct st_plugin_dl *tmp;

  for (i= 0; i < plugin_dl_array.elements; i++)

  {

    tmp= *dynamic_element(&plugin_dl_array, i, struct st_plugin_dl **);

    if (! tmp->ref_count)

    {

      memcpy(tmp, plugin_dl, sizeof(struct st_plugin_dl));

      return(tmp);

    }

  }

  if (insert_dynamic(&plugin_dl_array, (unsigned char*)&plugin_dl))

    return(0);

  tmp= *dynamic_element(&plugin_dl_array, plugin_dl_array.elements - 1,

                        struct st_plugin_dl **)=

      (struct st_plugin_dl *) memdup_root(&plugin_mem_root, (unsigned char*)plugin_dl,

                                           sizeof(struct st_plugin_dl));

  return(tmp);

}

static inline void free_plugin_mem(struct st_plugin_dl *p)

{

  if (p->handle)

    dlclose(p->handle);

  free(p->dl.str);

}

static st_plugin_dl *plugin_dl_add(const LEX_STRING *dl, int report)

{

  char dlpath[FN_REFLEN];

  uint32_t plugin_dir_len, dummy_errors, dlpathlen;

  struct st_plugin_dl *tmp, plugin_dl;

  void *sym;

  plugin_dir_len= strlen(opt_plugin_dir);

  /*

    Ensure that the dll doesn't have a path.

    This is done to ensure that only approved libraries from the

    plugin directory are used (to make this even remotely secure).

  */

  if (strchr(dl->str, FN_LIBCHAR) ||

      check_string_char_length((LEX_STRING *) dl, "", NAME_CHAR_LEN,

                               system_charset_info, 1) ||

      plugin_dir_len + dl->length + 1 >= FN_REFLEN)

  {

    if (report & REPORT_TO_USER)

      my_error(ER_UDF_NO_PATHS, MYF(0));

    if (report & REPORT_TO_LOG)

      sql_print_error(ER(ER_UDF_NO_PATHS));

    return(0);

  }

  /* If this dll is already loaded just increase ref_count. */

  if ((tmp= plugin_dl_find(dl)))

  {

    tmp->ref_count++;

    return(tmp);

  }

  memset(&plugin_dl, 0, sizeof(plugin_dl));

  /* Compile dll path */

  dlpathlen=

    strxnmov(dlpath, sizeof(dlpath) - 1, opt_plugin_dir, "/", dl->str, NULL) -

    dlpath;

  plugin_dl.ref_count= 1;

  /* Open new dll handle */

  if (!(plugin_dl.handle= dlopen(dlpath, RTLD_LAZY|RTLD_GLOBAL)))

  {

    const char *errmsg=dlerror();

    if (!strncmp(dlpath, errmsg, dlpathlen))

    { // if errmsg starts from dlpath, trim this prefix.

      errmsg+=dlpathlen;

      if (*errmsg == ':') errmsg++;

      if (*errmsg == ' ') errmsg++;

    }

    if (report & REPORT_TO_USER)

      my_error(ER_CANT_OPEN_LIBRARY, MYF(0), dlpath, errno, errmsg);

    if (report & REPORT_TO_LOG)

      sql_print_error(ER(ER_CANT_OPEN_LIBRARY), dlpath, errno, errmsg);

    return(0);

  }

  /* Find plugin declarations */

  if (!(sym= dlsym(plugin_dl.handle, plugin_declarations_sym)))

  {

    free_plugin_mem(&plugin_dl);

    if (report & REPORT_TO_USER)

      my_error(ER_CANT_FIND_DL_ENTRY, MYF(0), plugin_declarations_sym);

    if (report & REPORT_TO_LOG)

      sql_print_error(ER(ER_CANT_FIND_DL_ENTRY), plugin_declarations_sym);

    return(0);

  }

  plugin_dl.plugins= (struct st_mysql_plugin *)sym;

  /* Duplicate and convert dll name */

  plugin_dl.dl.length= dl->length * files_charset_info->mbmaxlen + 1;

  if (! (plugin_dl.dl.str= (char*) my_malloc(plugin_dl.dl.length, MYF(0))))

  {

    free_plugin_mem(&plugin_dl);

    if (report & REPORT_TO_USER)

      my_error(ER_OUTOFMEMORY, MYF(0), plugin_dl.dl.length);

    if (report & REPORT_TO_LOG)

      sql_print_error(ER(ER_OUTOFMEMORY), plugin_dl.dl.length);

    return(0);

  }

  plugin_dl.dl.length= copy_and_convert(plugin_dl.dl.str, plugin_dl.dl.length,

    files_charset_info, dl->str, dl->length, system_charset_info,

    &dummy_errors);

  plugin_dl.dl.str[plugin_dl.dl.length]= 0;

  /* Add this dll to array */

  if (! (tmp= plugin_dl_insert_or_reuse(&plugin_dl)))

  {

    free_plugin_mem(&plugin_dl);

    if (report & REPORT_TO_USER)

      my_error(ER_OUTOFMEMORY, MYF(0), sizeof(struct st_plugin_dl));

    if (report & REPORT_TO_LOG)

      sql_print_error(ER(ER_OUTOFMEMORY), sizeof(struct st_plugin_dl));

    return(0);

  }

  return(tmp);

}

static void plugin_dl_del(const LEX_STRING *dl)

{

  uint32_t i;

  for (i= 0; i < plugin_dl_array.elements; i++)

  {

    struct st_plugin_dl *tmp= *dynamic_element(&plugin_dl_array, i,

                                               struct st_plugin_dl **);

    if (tmp->ref_count &&

        ! my_strnncoll(files_charset_info,

                       (const unsigned char *)dl->str, dl->length,

                       (const unsigned char *)tmp->dl.str, tmp->dl.length))

    {

      /* Do not remove this element, unless no other plugin uses this dll. */

      if (! --tmp->ref_count)

      {

        free_plugin_mem(tmp);

        memset(tmp, 0, sizeof(struct st_plugin_dl));

      }

      break;

    }

  }

  return;

}

static struct st_plugin_int *plugin_find_internal(const LEX_STRING *name, int type)

{

  uint32_t i;

  if (! initialized)

    return(0);

  if (type == DRIZZLE_ANY_PLUGIN)

  {

    for (i= 0; i < DRIZZLE_MAX_PLUGIN_TYPE_NUM; i++)

    {

      struct st_plugin_int *plugin= (st_plugin_int *)

        hash_search(&plugin_hash[i], (const unsigned char *)name->str, name->length);

      if (plugin)

        return(plugin);

    }

  }

  else

    return((st_plugin_int *)

        hash_search(&plugin_hash[type], (const unsigned char *)name->str, name->length));

  return(0);

}

static SHOW_COMP_OPTION plugin_status(const LEX_STRING *name, int type)

{

  SHOW_COMP_OPTION rc= SHOW_OPTION_NO;

  struct st_plugin_int *plugin;

  if ((plugin= plugin_find_internal(name, type)))

  {

    rc= SHOW_OPTION_DISABLED;

    if (plugin->state == PLUGIN_IS_READY)

      rc= SHOW_OPTION_YES;

  }

  return(rc);

}

bool plugin_is_ready(const LEX_STRING *name, int type)

{

  bool rc= false;

  if (plugin_status(name, type) == SHOW_OPTION_YES)

    rc= true;

  return rc;

}

SHOW_COMP_OPTION sys_var_have_plugin::get_option()

{

  LEX_STRING plugin_name= { (char *) plugin_name_str, plugin_name_len };

  return plugin_status(&plugin_name, plugin_type);

}

static plugin_ref intern_plugin_lock(LEX *lex, plugin_ref rc CALLER_INFO_PROTO)

{

  st_plugin_int *pi= plugin_ref_to_int(rc);

  if (pi->state & (PLUGIN_IS_READY | PLUGIN_IS_UNINITIALIZED))

  {

    plugin_ref plugin;

    /*

      For debugging, we do an additional malloc which allows the

      memory manager and/or valgrind to track locked references and

      double unlocks to aid resolving reference counting.problems.

    */

    if (!(plugin= (plugin_ref) my_malloc_ci(sizeof(pi), MYF(MY_WME))))

      return(NULL);

    *plugin= pi;

    pi->ref_count++;

    if (lex)

      insert_dynamic(&lex->plugins, (unsigned char*)&plugin);

    return(plugin);

  }

  return(NULL);

}

plugin_ref plugin_lock(THD *thd, plugin_ref *ptr CALLER_INFO_PROTO)

{

  LEX *lex= thd ? thd->lex : 0;

  plugin_ref rc;

  rc= my_intern_plugin_lock_ci(lex, *ptr);

  return(rc);

}

plugin_ref plugin_lock_by_name(THD *thd, const LEX_STRING *name, int type

                               CALLER_INFO_PROTO)

{

  LEX *lex= thd ? thd->lex : 0;

  plugin_ref rc= NULL;

  st_plugin_int *plugin;

  if ((plugin= plugin_find_internal(name, type)))

    rc= my_intern_plugin_lock_ci(lex, plugin_int_to_ref(plugin));

  return(rc);

}

static st_plugin_int *plugin_insert_or_reuse(struct st_plugin_int *plugin)

{

  uint32_t i;

  struct st_plugin_int *tmp;

  for (i= 0; i < plugin_array.elements; i++)

  {

    tmp= *dynamic_element(&plugin_array, i, struct st_plugin_int **);

    if (tmp->state == PLUGIN_IS_FREED)

    {

      memcpy(tmp, plugin, sizeof(struct st_plugin_int));

      return(tmp);

    }

  }

  if (insert_dynamic(&plugin_array, (unsigned char*)&plugin))

    return(0);

  tmp= *dynamic_element(&plugin_array, plugin_array.elements - 1,

                        struct st_plugin_int **)=

       (struct st_plugin_int *) memdup_root(&plugin_mem_root, (unsigned char*)plugin,

                                            sizeof(struct st_plugin_int));

  return(tmp);

}

/*

  NOTE

    Requires that a write-lock is held on LOCK_system_variables_hash

*/

static bool plugin_add(MEM_ROOT *tmp_root,

                       const LEX_STRING *name, const LEX_STRING *dl,

                       int *argc, char **argv, int report)

{

  struct st_plugin_int tmp;

  struct st_mysql_plugin *plugin;

  if (plugin_find_internal(name, DRIZZLE_ANY_PLUGIN))

  {

    if (report & REPORT_TO_USER)

      my_error(ER_UDF_EXISTS, MYF(0), name->str);

    if (report & REPORT_TO_LOG)

      sql_print_error(ER(ER_UDF_EXISTS), name->str);

    return(true);

  }

  /* Clear the whole struct to catch future extensions. */

  memset(&tmp, 0, sizeof(tmp));

  if (! (tmp.plugin_dl= plugin_dl_add(dl, report)))

    return(true);

  /* Find plugin by name */

  for (plugin= tmp.plugin_dl->plugins; plugin->name; plugin++)

  {

    uint32_t name_len= strlen(plugin->name);

    if (plugin->type >= 0 && plugin->type < DRIZZLE_MAX_PLUGIN_TYPE_NUM &&

        ! my_strnncoll(system_charset_info,

                       (const unsigned char *)name->str, name->length,

                       (const unsigned char *)plugin->name,

                       name_len))

    {

      struct st_plugin_int *tmp_plugin_ptr;

      tmp.plugin= plugin;

      tmp.name.str= (char *)plugin->name;

      tmp.name.length= name_len;

      tmp.ref_count= 0;

      tmp.state= PLUGIN_IS_UNINITIALIZED;

      if (!test_plugin_options(tmp_root, &tmp, argc, argv))

      {

        if ((tmp_plugin_ptr= plugin_insert_or_reuse(&tmp)))

        {

          plugin_array_version++;

          if (!my_hash_insert(&plugin_hash[plugin->type], (unsigned char*)tmp_plugin_ptr))

          {

            init_alloc_root(&tmp_plugin_ptr->mem_root, 4096, 4096);

            return(false);

          }

          tmp_plugin_ptr->state= PLUGIN_IS_FREED;

        }

        mysql_del_sys_var_chain(tmp.system_vars);

        goto err;

      }

      /* plugin was disabled */

      plugin_dl_del(dl);

      return(false);

    }

  }

  if (report & REPORT_TO_USER)

    my_error(ER_CANT_FIND_DL_ENTRY, MYF(0), name->str);

  if (report & REPORT_TO_LOG)

    sql_print_error(ER(ER_CANT_FIND_DL_ENTRY), name->str);

err:

  plugin_dl_del(dl);

  return(true);

}

static void plugin_deinitialize(struct st_plugin_int *plugin, bool ref_check)

{

  if (plugin->plugin->status_vars)

  {

#ifdef FIX_LATER

    /*

      We have a problem right now where we can not prepend without

      breaking backwards compatibility. We will fix this shortly so

      that engines have "use names" and we wil use those for

      CREATE TABLE, and use the plugin name then for adding automatic

      variable names.

    */

    SHOW_VAR array[2]= {

      {plugin->plugin->name, (char*)plugin->plugin->status_vars, SHOW_ARRAY},

      {0, 0, SHOW_UNDEF}

    };

    remove_status_vars(array);

#else

    remove_status_vars(plugin->plugin->status_vars);

#endif /* FIX_LATER */

  }

  if (plugin_type_deinitialize[plugin->plugin->type])

  {

    if ((*plugin_type_deinitialize[plugin->plugin->type])(plugin))

    {

      sql_print_error(_("Plugin '%s' of type %s failed deinitialization"),

                      plugin->name.str, plugin_type_names[plugin->plugin->type].str);

    }

  }

  else if (plugin->plugin->deinit)

    plugin->plugin->deinit(plugin);

  plugin->state= PLUGIN_IS_UNINITIALIZED;