~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 <mysys/hash.h>

#include <drizzled/authentication.h>

#include <drizzled/logging.h>

#include <drizzled/errmsg.h>

#include <drizzled/qcache.h>

#include <drizzled/sql_parse.h>

#include <drizzled/scheduling.h>

#include <drizzled/replication_services.h>

#include <drizzled/show.h>

#include <drizzled/handler.h>

#include <drizzled/set_var.h>

#include <drizzled/session.h>

#include <drizzled/item/null.h>

#include <drizzled/plugin/registry.h>

#include "drizzled/plugin/config.h"

#include <string>

#include <vector>

#include <map>

#include <algorithm>

#include <drizzled/error.h>

#include <drizzled/gettext.h>

#define REPORT_TO_LOG  1

#define REPORT_TO_USER 2

using namespace std;

using namespace drizzled;

typedef plugin::Manifest builtin_plugin[];

extern builtin_plugin PANDORA_BUILTIN_LIST;

static plugin::Manifest *drizzled_builtins[]=

{

  PANDORA_BUILTIN_LIST,(plugin::Manifest *)NULL

};

class sys_var_pluginvar;

static vector<sys_var_pluginvar *> plugin_sysvar_vec;

char *opt_plugin_load= NULL;

const char *opt_plugin_load_default= QUOTE_ARG(PANDORA_PLUGIN_LIST);

char *opt_plugin_dir_ptr;

char opt_plugin_dir[FN_REFLEN];

static const char *plugin_declarations_sym= "_drizzled_plugin_declaration_";

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

   sub-structure (plugin->info).

*/

static bool initialized= false;

static DYNAMIC_ARRAY plugin_dl_array;

static DYNAMIC_ARRAY plugin_array;

static bool reap_needed= false;

/*

  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 session 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:

  plugin::Handle *plugin;

  struct st_mysql_sys_var *plugin_var;

  sys_var_pluginvar(const std::string 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_SessionLOCAL) && type != OPT_GLOBAL; }

  bool check_update_type(Item_result type);

  SHOW_TYPE show_type();

  unsigned char* real_value_ptr(Session *session, enum_var_type type);

  TYPELIB* plugin_var_typelib(void);

  unsigned char* value_ptr(Session *session, enum_var_type type,

                           const LEX_STRING *base);

  bool check(Session *session, set_var *var);

  bool check_default(enum_var_type)

    { return is_readonly(); }

  void set_default(Session *session, enum_var_type);

  bool update(Session *session, set_var *var);

};

/* prototypes */

static bool plugin_load_list(plugin::Registry &registry,

                             MEM_ROOT *tmp_root, int *argc, char **argv,

                             const char *list);

static int test_plugin_options(MEM_ROOT *, plugin::Handle *,

                               int *, char **);

static bool register_builtin(plugin::Registry &registry,

                             plugin::Handle *,

                             plugin::Handle **);

static void unlock_variables(Session *session, struct system_variables *vars);

static void cleanup_variables(Session *session, 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);

static void reap_plugins(plugin::Registry &plugins);

/* 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(Session *session, bool fixed, bool unsignd,

                                 const std::string &name, int64_t val);

static bool throw_bounds_warning(Session *session, bool fixed, bool unsignd,

                                 const char *name, int64_t val)

{

  const std::string name_str(name);

  return throw_bounds_warning(session, fixed, unsignd, name_str, 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_session->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 plugin::Library *plugin_dl_find(const LEX_STRING *dl)

{

  uint32_t i;

  plugin::Library *tmp;

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

  {

    tmp= *dynamic_element(&plugin_dl_array, i, plugin::Library **);

    if (! 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 plugin::Library *plugin_dl_insert_or_reuse(plugin::Library *plugin_dl)

{

  uint32_t i;

  plugin::Library *tmp;

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

  {

    tmp= *dynamic_element(&plugin_dl_array, i, plugin::Library **);

    {

      memcpy(tmp, plugin_dl, sizeof(plugin::Library));

      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,

                        plugin::Library **)=

      (plugin::Library *) memdup_root(&plugin_mem_root,

                                      (unsigned char*)plugin_dl,

                                      sizeof(plugin::Library));

  return(tmp);

}

static inline void free_plugin_mem(plugin::Library *p)

{

  if (p->handle)

    dlclose(p->handle);

  free(p->dl.str);

}

static plugin::Library *plugin_dl_add(const LEX_STRING *dl, int report)

{

  string dlpath;

  uint32_t plugin_dir_len;

  plugin::Library *tmp, plugin_dl;

  void *sym;

  plugin_dir_len= strlen(opt_plugin_dir);

  dlpath.reserve(FN_REFLEN);

  /*

    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)

      errmsg_printf(ERRMSG_LVL_ERROR, "%s",ER(ER_UDF_NO_PATHS));

    return(0);

  }

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

  if ((tmp= plugin_dl_find(dl)))

  {

    return(tmp);

  }

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

  /* Compile dll path */

  dlpath.append(opt_plugin_dir);

  dlpath.append("/");

  dlpath.append(dl->str);

  /* Open new dll handle */

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

  {

    const char *errmsg=dlerror();

    uint32_t dlpathlen= dlpath.length();

    if (!dlpath.compare(0, dlpathlen, errmsg))

    { // 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.c_str(), errno, errmsg);

    if (report & REPORT_TO_LOG)

      errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_CANT_OPEN_LIBRARY), dlpath.c_str(), 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)

      errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_CANT_FIND_DL_ENTRY), plugin_declarations_sym);

    return(0);

  }

  plugin_dl.plugins= static_cast<plugin::Manifest *>(sym);

  /* Duplicate and convert dll name */

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

  if (! (plugin_dl.dl.str= (char*) calloc(plugin_dl.dl.length, sizeof(char))))

  {

    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)

      errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_OUTOFMEMORY), plugin_dl.dl.length);

    return(0);

  }

  strcpy(plugin_dl.dl.str, dl->str);

  /* 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(plugin::Library));

    if (report & REPORT_TO_LOG)

      errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_OUTOFMEMORY),

                    sizeof(plugin::Library));

    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++)

  {

    plugin::Library *tmp= *dynamic_element(&plugin_dl_array, i,

                                           plugin::Library **);

    if (! 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. */

      {

        free_plugin_mem(tmp);

        memset(tmp, 0, sizeof(plugin::Library));

      }

      break;

    }

  }

  return;

}

static plugin::Handle *plugin_insert_or_reuse(plugin::Handle *plugin)

{

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

    return(0);

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

                        plugin::Handle **);

  return(plugin);

}

/*

  NOTE

    Requires that a write-lock is held on LOCK_system_variables_hash

*/

static bool plugin_add(plugin::Registry &registry, MEM_ROOT *tmp_root,

                       const LEX_STRING *name, const LEX_STRING *dl,

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

{

  plugin::Manifest *manifest;

  if (! initialized)

    return(0);

  if (registry.find(name))

  {

    if (report & REPORT_TO_USER)

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

    if (report & REPORT_TO_LOG)

      errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_UDF_EXISTS), name->str);

    return(true);

  }

  plugin::Library *library= plugin_dl_add(dl, report);

  if (library == NULL)

    return true;

  plugin::Handle *tmp= NULL;

  /* Find plugin by name */

  for (manifest= library->plugins; manifest->name; manifest++)

  {

    if (! my_strnncoll(system_charset_info,

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

                       (const unsigned char *)manifest->name,

                       strlen(manifest->name)))

    {

      tmp= new (std::nothrow) plugin::Handle(manifest, library);

      if (tmp == NULL)

        return true;

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

      {

        if ((tmp= plugin_insert_or_reuse(tmp)))

        {

          registry.add(tmp);

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

          return(false);

        }

        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)

    errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_CANT_FIND_DL_ENTRY), name->str);

err:

  plugin_dl_del(dl);

  return(true);

}

static void plugin_del(plugin::Registry &registry, plugin::Handle *plugin)

{

  if (plugin->isInited)

  {

    if (plugin->getManifest().status_vars)

    {

      remove_status_vars(plugin->getManifest().status_vars);

    }

    if (plugin->getManifest().deinit)

      plugin->getManifest().deinit(registry);

  }

  /* Free allocated strings before deleting the plugin. */

  plugin_vars_free_values(plugin->system_vars);

  if (plugin->plugin_dl)

    plugin_dl_del(&plugin->plugin_dl->dl);

  plugin->isInited= false;

  pthread_rwlock_wrlock(&LOCK_system_variables_hash);

  mysql_del_sys_var_chain(plugin->system_vars);

  pthread_rwlock_unlock(&LOCK_system_variables_hash);

  delete plugin;

}

static void reap_plugins(plugin::Registry &plugins)

{

  size_t count;

  uint32_t idx;

  plugin::Handle *plugin;

  count= plugin_array.elements;

  for (idx= 0; idx < count; idx++)

  {

    plugin= *dynamic_element(&plugin_array, idx, plugin::Handle **);

    plugin_del(plugins, plugin);

  }

  drizzle_del_plugin_sysvar();

}

static void plugin_initialize_vars(plugin::Handle *plugin)

{

  if (plugin->getManifest().status_vars)

  {

    add_status_vars(plugin->getManifest().status_vars); // add_status_vars makes a copy

  }

  /*

    set the plugin attribute of plugin's sys vars so they are pointing

    to the active plugin

  */

  if (plugin->system_vars)

  {

    sys_var_pluginvar *var= plugin->system_vars->cast_pluginvar();

    for (;;)

    {

      var->plugin= plugin;

      if (! var->getNext())

        break;

      var= var->getNext()->cast_pluginvar();

    }

  }

}

static bool plugin_initialize(plugin::Registry &registry,

                              plugin::Handle *plugin)

{

  assert(plugin->isInited == false);

  if (plugin->getManifest().init)

  {

    if (plugin->getManifest().init(registry))

    {

      errmsg_printf(ERRMSG_LVL_ERROR,

                    _("Plugin '%s' init function returned error.\n"),

                    plugin->getName().c_str());

      return true;

    }

  }

  plugin->isInited= true;

  return false;

}

extern "C" unsigned char *get_bookmark_hash_key(const unsigned char *, size_t *, bool);

unsigned char *get_bookmark_hash_key(const unsigned char *buff, size_t *length, bool)

{

  struct st_bookmark *var= (st_bookmark *)buff;

  *length= var->name_len + 1;

  return (unsigned char*) var->key;

}

/*

  The logic is that we first load and initialize all compiled in plugins.

  From there we load up the dynamic types (assuming we have not been told to

  skip this part).

  Finally we initialize everything, aka the dynamic that have yet to initialize.

*/

int plugin_init(plugin::Registry &registry, int *argc, char **argv, int flags)

{

  uint32_t idx;

  plugin::Manifest **builtins;

  plugin::Manifest *manifest;

  plugin::Handle *handle;

  MEM_ROOT tmp_root;

  if (initialized)

    return(0);

  init_alloc_root(&plugin_mem_root, 4096, 4096);

  init_alloc_root(&tmp_root, 4096, 4096);

  if (hash_init(&bookmark_hash, &my_charset_bin, 16, 0, 0,

                  get_bookmark_hash_key, NULL, HASH_UNIQUE))

      goto err;

  if (my_init_dynamic_array(&plugin_dl_array,

                            sizeof(plugin::Library *),16,16) ||

      my_init_dynamic_array(&plugin_array,

                            sizeof(plugin::Handle *),16,16))

    goto err;

  initialized= 1;

  /*

    First we register builtin plugins

  */

  for (builtins= drizzled_builtins; *builtins; builtins++)

  {

    for (manifest= *builtins; manifest->name; manifest++)

    {

      handle= new (std::nothrow) plugin::Handle(manifest);

      if (handle == NULL)