← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_plugin.cc

  • Committer: Padraig O'Sullivan
  • Date: 2009-08-08 04:22:33 UTC
  • mto: (1115.3.4 captain)
  • mto: This revision was merged to the branch mainline in revision 1117.
  • Revision ID: osullivan.padraig@gmail.com-20090808042233-q0z88zc490z3f3r7
Renamed the Command class to be Statement. Renamed the command directory to
statement and also the command header file to statement. Updated various
source files to reflect this renaming.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_plugin.cc
13
13
   along with this program; if not, write to the Free Software
14
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
 
#include "config.h"
 
16
#include <drizzled/server_includes.h>
 
17
#include <mysys/my_getopt.h>
 
18
#include <mysys/hash.h>
17
19
 
18
 
#include <dlfcn.h>
 
20
#include <drizzled/authentication.h>
 
21
#include <drizzled/logging.h>
 
22
#include <drizzled/errmsg.h>
 
23
#include <drizzled/qcache.h>
 
24
#include <drizzled/sql_parse.h>
 
25
#include <drizzled/scheduling.h>
 
26
#include <drizzled/replication_services.h>
 
27
#include <drizzled/show.h>
 
28
#include <drizzled/handler.h>
 
29
#include <drizzled/set_var.h>
 
30
#include <drizzled/session.h>
 
31
#include <drizzled/item/null.h>
 
32
#include <drizzled/plugin_registry.h>
19
33
 
20
34
#include <string>
21
35
#include <vector>
22
36
#include <map>
23
37
#include <algorithm>
24
38
 
25
 
#include "drizzled/option.h"
26
 
#include "drizzled/my_hash.h"
27
 
#include "drizzled/internal/m_string.h"
28
 
 
29
 
#include "drizzled/plugin.h"
30
 
#include "drizzled/plugin/load_list.h"
31
 
#include "drizzled/sql_parse.h"
32
 
#include "drizzled/show.h"
33
 
#include "drizzled/cursor.h"
34
 
#include "drizzled/set_var.h"
35
 
#include "drizzled/session.h"
36
 
#include "drizzled/item/null.h"
37
 
#include "drizzled/plugin/registry.h"
38
 
#include "drizzled/error.h"
39
 
#include "drizzled/gettext.h"
40
 
#include "drizzled/errmsg_print.h"
41
 
#include "drizzled/plugin/library.h"
42
 
#include "drizzled/strfunc.h"
43
 
#include "drizzled/pthread_globals.h"
44
 
#include "drizzled/util/tokenize.h"
45
 
 
46
 
/* FreeBSD 2.2.2 does not define RTLD_NOW) */
47
 
#ifndef RTLD_NOW
48
 
#define RTLD_NOW 1
49
 
#endif
 
39
#include <drizzled/error.h>
 
40
#include <drizzled/gettext.h>
 
41
 
 
42
#define REPORT_TO_LOG  1
 
43
#define REPORT_TO_USER 2
50
44
 
51
45
using namespace std;
52
 
 
53
 
typedef drizzled::plugin::Manifest drizzled_builtin_plugin[];
54
 
extern drizzled_builtin_plugin PANDORA_BUILTIN_LIST;
55
 
static drizzled::plugin::Manifest *drizzled_builtins[]=
56
 
{
57
 
  PANDORA_BUILTIN_LIST, NULL
58
 
};
59
 
 
60
 
namespace drizzled
61
 
{
 
46
using namespace drizzled;
62
47
 
63
 
 
 
48
typedef plugin::Manifest builtin_plugin[];
 
49
extern builtin_plugin DRIZZLED_BUILTIN_LIST;
 
50
static plugin::Manifest *drizzled_builtins[]=
 
51
{
 
52
  DRIZZLED_BUILTIN_LIST,(plugin::Manifest *)NULL
 
53
};
64
54
class sys_var_pluginvar;
65
55
static vector<sys_var_pluginvar *> plugin_sysvar_vec;
66
56
 
67
 
char *opt_plugin_add= NULL;
68
 
char *opt_plugin_remove= NULL;
69
57
char *opt_plugin_load= NULL;
 
58
const char *opt_plugin_load_default= QUOTE_ARG(DRIZZLED_PLUGIN_LIST);
70
59
char *opt_plugin_dir_ptr;
71
60
char opt_plugin_dir[FN_REFLEN];
72
 
const char *opt_plugin_load_default= PANDORA_PLUGIN_LIST;
 
61
static const char *plugin_declarations_sym= "_drizzled_plugin_declaration_";
73
62
 
74
63
/* Note that 'int version' must be the first field of every plugin
75
64
   sub-structure (plugin->info).
77
66
 
78
67
static bool initialized= false;
79
68
 
 
69
static DYNAMIC_ARRAY plugin_dl_array;
 
70
static DYNAMIC_ARRAY plugin_array;
80
71
 
81
72
static bool reap_needed= false;
82
73
 
84
75
  write-lock on LOCK_system_variables_hash is required before modifying
85
76
  the following variables/structures
86
77
*/
87
 
static memory::Root plugin_mem_root;
 
78
static MEM_ROOT plugin_mem_root;
88
79
static uint32_t global_variables_dynamic_size= 0;
89
80
static HASH bookmark_hash;
90
81
 
93
84
  hidden part of opaque value passed to variable check functions.
94
85
  Used to provide a object-like structure to non C++ consumers.
95
86
*/
96
 
struct st_item_value_holder : public drizzle_value
 
87
struct st_item_value_holder : public st_mysql_value
97
88
{
98
89
  Item *item;
99
90
};
120
111
 
121
112
 
122
113
/*
 
114
  skeleton of a plugin variable - portion of structure common to all.
 
115
*/
 
116
struct st_mysql_sys_var
 
117
{
 
118
  DRIZZLE_PLUGIN_VAR_HEADER;
 
119
};
 
120
 
 
121
 
 
122
/*
123
123
  sys_var class for access to all plugin variables visible to the user
124
124
*/
125
125
class sys_var_pluginvar: public sys_var
126
126
{
127
127
public:
128
 
  plugin::Module *plugin;
129
 
  drizzle_sys_var *plugin_var;
 
128
  plugin::Handle *plugin;
 
129
  struct st_mysql_sys_var *plugin_var;
130
130
 
131
131
  sys_var_pluginvar(const std::string name_arg,
132
 
                    drizzle_sys_var *plugin_var_arg)
 
132
                    struct st_mysql_sys_var *plugin_var_arg)
133
133
    :sys_var(name_arg), plugin_var(plugin_var_arg) {}
134
134
  sys_var_pluginvar *cast_pluginvar() { return this; }
135
135
  bool is_readonly() const { return plugin_var->flags & PLUGIN_VAR_READONLY; }
136
 
  bool check_type(sql_var_t type)
 
136
  bool check_type(enum_var_type type)
137
137
  { return !(plugin_var->flags & PLUGIN_VAR_SessionLOCAL) && type != OPT_GLOBAL; }
138
138
  bool check_update_type(Item_result type);
139
139
  SHOW_TYPE show_type();
140
 
  unsigned char* real_value_ptr(Session *session, sql_var_t type);
 
140
  unsigned char* real_value_ptr(Session *session, enum_var_type type);
141
141
  TYPELIB* plugin_var_typelib(void);
142
 
  unsigned char* value_ptr(Session *session, sql_var_t type,
 
142
  unsigned char* value_ptr(Session *session, enum_var_type type,
143
143
                           const LEX_STRING *base);
144
144
  bool check(Session *session, set_var *var);
145
 
  bool check_default(sql_var_t)
 
145
  bool check_default(enum_var_type)
146
146
    { return is_readonly(); }
147
 
  void set_default(Session *session, sql_var_t);
 
147
  void set_default(Session *session, enum_var_type);
148
148
  bool update(Session *session, set_var *var);
149
149
};
150
150
 
151
151
 
152
152
/* prototypes */
153
 
static void plugin_prune_list(vector<string> &plugin_list,
154
 
                              const vector<string> &plugins_to_remove);
155
 
static bool plugin_load_list(plugin::Registry &registry,
156
 
                             memory::Root *tmp_root, int *argc, char **argv,
157
 
                             const set<string> &plugin_list);
158
 
static int test_plugin_options(memory::Root *, plugin::Module *,
 
153
static bool plugin_load_list(MEM_ROOT *tmp_root, int *argc, char **argv,
 
154
                             const char *list);
 
155
static int test_plugin_options(MEM_ROOT *, plugin::Handle *,
159
156
                               int *, char **);
 
157
static bool register_builtin(plugin::Handle *,
 
158
                             plugin::Handle **);
160
159
static void unlock_variables(Session *session, struct system_variables *vars);
161
160
static void cleanup_variables(Session *session, struct system_variables *vars);
162
161
static void plugin_vars_free_values(sys_var *vars);
 
162
static void plugin_opt_set_limits(struct my_option *options,
 
163
                                  const struct st_mysql_sys_var *opt);
 
164
static void reap_plugins(void);
 
165
 
163
166
 
164
167
/* declared in set_var.cc */
165
168
extern sys_var *intern_find_sys_var(const char *str, uint32_t length, bool no_error);
177
180
  Value type thunks, allows the C world to play in the C++ world
178
181
****************************************************************************/
179
182
 
180
 
static int item_value_type(drizzle_value *value)
 
183
static int item_value_type(struct st_mysql_value *value)
181
184
{
182
185
  switch (((st_item_value_holder*)value)->item->result_type()) {
183
186
  case INT_RESULT:
189
192
  }
190
193
}
191
194
 
192
 
static const char *item_val_str(drizzle_value *value,
 
195
static const char *item_val_str(struct st_mysql_value *value,
193
196
                                char *buffer, int *length)
194
197
{
195
198
  String str(buffer, *length, system_charset_info), *res;
207
210
}
208
211
 
209
212
 
210
 
static int item_val_int(drizzle_value *value, int64_t *buf)
 
213
static int item_val_int(struct st_mysql_value *value, int64_t *buf)
211
214
{
212
215
  Item *item= ((st_item_value_holder*)value)->item;
213
216
  *buf= item->val_int();
217
220
}
218
221
 
219
222
 
220
 
static int item_val_real(drizzle_value *value, double *buf)
 
223
static int item_val_real(struct st_mysql_value *value, double *buf)
221
224
{
222
225
  Item *item= ((st_item_value_holder*)value)->item;
223
226
  *buf= item->val_real();
231
234
  Plugin support code
232
235
****************************************************************************/
233
236
 
234
 
 
 
237
static plugin::Library *plugin_dl_find(const LEX_STRING *dl)
 
238
{
 
239
  uint32_t i;
 
240
  plugin::Library *tmp;
 
241
 
 
242
  for (i= 0; i < plugin_dl_array.elements; i++)
 
243
  {
 
244
    tmp= *dynamic_element(&plugin_dl_array, i, plugin::Library **);
 
245
    if (! my_strnncoll(files_charset_info,
 
246
                       (const unsigned char *)dl->str, dl->length,
 
247
                       (const unsigned char *)tmp->dl.str, tmp->dl.length))
 
248
      return(tmp);
 
249
  }
 
250
  return(0);
 
251
}
 
252
 
 
253
static plugin::Library *plugin_dl_insert_or_reuse(plugin::Library *plugin_dl)
 
254
{
 
255
  uint32_t i;
 
256
  plugin::Library *tmp;
 
257
 
 
258
  for (i= 0; i < plugin_dl_array.elements; i++)
 
259
  {
 
260
    tmp= *dynamic_element(&plugin_dl_array, i, plugin::Library **);
 
261
    {
 
262
      memcpy(tmp, plugin_dl, sizeof(plugin::Library));
 
263
      return(tmp);
 
264
    }
 
265
  }
 
266
  if (insert_dynamic(&plugin_dl_array, (unsigned char*)&plugin_dl))
 
267
    return(0);
 
268
  tmp= *dynamic_element(&plugin_dl_array, plugin_dl_array.elements - 1,
 
269
                        plugin::Library **)=
 
270
      (plugin::Library *) memdup_root(&plugin_mem_root,
 
271
                                      (unsigned char*)plugin_dl,
 
272
                                      sizeof(plugin::Library));
 
273
  return(tmp);
 
274
}
 
275
 
 
276
static inline void free_plugin_mem(plugin::Library *p)
 
277
{
 
278
  if (p->handle)
 
279
    dlclose(p->handle);
 
280
  free(p->dl.str);
 
281
}
 
282
 
 
283
 
 
284
static plugin::Library *plugin_dl_add(const LEX_STRING *dl, int report)
 
285
{
 
286
  string dlpath;
 
287
  uint32_t plugin_dir_len;
 
288
  plugin::Library *tmp, plugin_dl;
 
289
  void *sym;
 
290
  plugin_dir_len= strlen(opt_plugin_dir);
 
291
  dlpath.reserve(FN_REFLEN);
 
292
  /*
 
293
    Ensure that the dll doesn't have a path.
 
294
    This is done to ensure that only approved libraries from the
 
295
    plugin directory are used (to make this even remotely secure).
 
296
  */
 
297
  if (strchr(dl->str, FN_LIBCHAR) ||
 
298
      check_string_char_length((LEX_STRING *) dl, "", NAME_CHAR_LEN,
 
299
                               system_charset_info, 1) ||
 
300
      plugin_dir_len + dl->length + 1 >= FN_REFLEN)
 
301
  {
 
302
    if (report & REPORT_TO_USER)
 
303
      my_error(ER_UDF_NO_PATHS, MYF(0));
 
304
    if (report & REPORT_TO_LOG)
 
305
      errmsg_printf(ERRMSG_LVL_ERROR, "%s",ER(ER_UDF_NO_PATHS));
 
306
    return(0);
 
307
  }
 
308
  /* If this dll is already loaded just increase ref_count. */
 
309
  if ((tmp= plugin_dl_find(dl)))
 
310
  {
 
311
    return(tmp);
 
312
  }
 
313
  memset(&plugin_dl, 0, sizeof(plugin_dl));
 
314
  /* Compile dll path */
 
315
  dlpath.append(opt_plugin_dir);
 
316
  dlpath.append("/");
 
317
  dlpath.append(dl->str);
 
318
  /* Open new dll handle */
 
319
  if (!(plugin_dl.handle= dlopen(dlpath.c_str(), RTLD_LAZY|RTLD_GLOBAL)))
 
320
  {
 
321
    const char *errmsg=dlerror();
 
322
    uint32_t dlpathlen= dlpath.length();
 
323
    if (!dlpath.compare(0, dlpathlen, errmsg))
 
324
    { // if errmsg starts from dlpath, trim this prefix.
 
325
      errmsg+=dlpathlen;
 
326
      if (*errmsg == ':') errmsg++;
 
327
      if (*errmsg == ' ') errmsg++;
 
328
    }
 
329
    if (report & REPORT_TO_USER)
 
330
      my_error(ER_CANT_OPEN_LIBRARY, MYF(0), dlpath.c_str(), errno, errmsg);
 
331
    if (report & REPORT_TO_LOG)
 
332
      errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_CANT_OPEN_LIBRARY), dlpath.c_str(), errno, errmsg);
 
333
    return(0);
 
334
  }
 
335
 
 
336
  /* Find plugin declarations */
 
337
  if (!(sym= dlsym(plugin_dl.handle, plugin_declarations_sym)))
 
338
  {
 
339
    free_plugin_mem(&plugin_dl);
 
340
    if (report & REPORT_TO_USER)
 
341
      my_error(ER_CANT_FIND_DL_ENTRY, MYF(0), plugin_declarations_sym);
 
342
    if (report & REPORT_TO_LOG)
 
343
      errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_CANT_FIND_DL_ENTRY), plugin_declarations_sym);
 
344
    return(0);
 
345
  }
 
346
 
 
347
  plugin_dl.plugins= static_cast<plugin::Manifest *>(sym);
 
348
 
 
349
  /* Duplicate and convert dll name */
 
350
  plugin_dl.dl.length= dl->length * files_charset_info->mbmaxlen + 1;
 
351
  if (! (plugin_dl.dl.str= (char*) calloc(plugin_dl.dl.length, sizeof(char))))
 
352
  {
 
353
    free_plugin_mem(&plugin_dl);
 
354
    if (report & REPORT_TO_USER)
 
355
      my_error(ER_OUTOFMEMORY, MYF(0), plugin_dl.dl.length);
 
356
    if (report & REPORT_TO_LOG)
 
357
      errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_OUTOFMEMORY), plugin_dl.dl.length);
 
358
    return(0);
 
359
  }
 
360
  strcpy(plugin_dl.dl.str, dl->str);
 
361
  /* Add this dll to array */
 
362
  if (! (tmp= plugin_dl_insert_or_reuse(&plugin_dl)))
 
363
  {
 
364
    free_plugin_mem(&plugin_dl);
 
365
    if (report & REPORT_TO_USER)
 
366
      my_error(ER_OUTOFMEMORY, MYF(0), sizeof(plugin::Library));
 
367
    if (report & REPORT_TO_LOG)
 
368
      errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_OUTOFMEMORY),
 
369
                    sizeof(plugin::Library));
 
370
    return(0);
 
371
  }
 
372
  return(tmp);
 
373
}
 
374
 
 
375
 
 
376
static void plugin_dl_del(const LEX_STRING *dl)
 
377
{
 
378
  uint32_t i;
 
379
 
 
380
  for (i= 0; i < plugin_dl_array.elements; i++)
 
381
  {
 
382
    plugin::Library *tmp= *dynamic_element(&plugin_dl_array, i,
 
383
                                           plugin::Library **);
 
384
    if (! my_strnncoll(files_charset_info,
 
385
                       (const unsigned char *)dl->str, dl->length,
 
386
                       (const unsigned char *)tmp->dl.str, tmp->dl.length))
 
387
    {
 
388
      /* Do not remove this element, unless no other plugin uses this dll. */
 
389
      {
 
390
        free_plugin_mem(tmp);
 
391
        memset(tmp, 0, sizeof(plugin::Library));
 
392
      }
 
393
      break;
 
394
    }
 
395
  }
 
396
  return;
 
397
}
 
398
 
 
399
 
 
400
 
 
401
static plugin::Handle *plugin_insert_or_reuse(plugin::Handle *plugin)
 
402
{
 
403
  if (insert_dynamic(&plugin_array, (unsigned char*)&plugin))
 
404
    return(0);
 
405
  plugin= *dynamic_element(&plugin_array, plugin_array.elements - 1,
 
406
                        plugin::Handle **);
 
407
  return(plugin);
 
408
}
235
409
 
236
410
 
237
411
/*
238
412
  NOTE
239
413
    Requires that a write-lock is held on LOCK_system_variables_hash
240
414
*/
241
 
static bool plugin_add(plugin::Registry &registry, memory::Root *tmp_root,
242
 
                       plugin::Library *library,
243
 
                       int *argc, char **argv)
 
415
static bool plugin_add(MEM_ROOT *tmp_root,
 
416
                       const LEX_STRING *name, const LEX_STRING *dl,
 
417
                       int *argc, char **argv, int report)
244
418
{
 
419
  PluginRegistry &registry= PluginRegistry::getPluginRegistry();
 
420
 
 
421
  plugin::Manifest *manifest;
245
422
  if (! initialized)
246
 
    return true;
 
423
    return(0);
247
424
 
248
 
  if (registry.find(library->getName()))
 
425
  if (registry.find(name))
249
426
  {
250
 
    errmsg_printf(ERRMSG_LVL_WARN, ER(ER_PLUGIN_EXISTS),
251
 
                  library->getName().c_str());
252
 
    return false;
 
427
    if (report & REPORT_TO_USER)
 
428
      my_error(ER_UDF_EXISTS, MYF(0), name->str);
 
429
    if (report & REPORT_TO_LOG)
 
430
      errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_UDF_EXISTS), name->str);
 
431
    return(true);
253
432
  }
 
433
  plugin::Library *library= plugin_dl_add(dl, report);
 
434
  if (library == NULL)
 
435
    return true;
254
436
 
255
 
  plugin::Module *tmp= NULL;
 
437
  plugin::Handle *tmp= NULL;
256
438
  /* Find plugin by name */
257
 
  const plugin::Manifest *manifest= library->getManifest();
258
 
 
259
 
  if (registry.find(manifest->name))
260
 
  {
261
 
    errmsg_printf(ERRMSG_LVL_ERROR, 
262
 
                  _("Plugin '%s' contains the name '%s' in its manifest, which "
263
 
                    "has already been registered.\n"),
264
 
                  library->getName().c_str(),
265
 
                  manifest->name);
266
 
    return true;
267
 
  }
268
 
 
269
 
  tmp= new (std::nothrow) plugin::Module(manifest, library);
270
 
  if (tmp == NULL)
271
 
    return true;
272
 
 
273
 
  if (!test_plugin_options(tmp_root, tmp, argc, argv))
274
 
  {
275
 
    registry.add(tmp);
276
 
    return false;
277
 
  }
278
 
  errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_CANT_FIND_DL_ENTRY),
279
 
                library->getName().c_str());
280
 
  return true;
 
439
  for (manifest= library->plugins; manifest->name; manifest++)
 
440
  {
 
441
    if (! my_strnncoll(system_charset_info,
 
442
                       (const unsigned char *)name->str, name->length,
 
443
                       (const unsigned char *)manifest->name,
 
444
                       strlen(manifest->name)))
 
445
    {
 
446
      tmp= new (std::nothrow) plugin::Handle(manifest, library);
 
447
      if (tmp == NULL)
 
448
        return true;
 
449
 
 
450
      if (!test_plugin_options(tmp_root, tmp, argc, argv))
 
451
      {
 
452
        if ((tmp= plugin_insert_or_reuse(tmp)))
 
453
        {
 
454
          registry.add(tmp);
 
455
          init_alloc_root(&tmp->mem_root, 4096, 4096);
 
456
          return(false);
 
457
        }
 
458
        mysql_del_sys_var_chain(tmp->system_vars);
 
459
        goto err;
 
460
      }
 
461
      /* plugin was disabled */
 
462
      plugin_dl_del(dl);
 
463
      return(false);
 
464
    }
 
465
  }
 
466
  if (report & REPORT_TO_USER)
 
467
    my_error(ER_CANT_FIND_DL_ENTRY, MYF(0), name->str);
 
468
  if (report & REPORT_TO_LOG)
 
469
    errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_CANT_FIND_DL_ENTRY), name->str);
 
470
err:
 
471
  plugin_dl_del(dl);
 
472
  return(true);
281
473
}
282
474
 
283
475
 
284
 
static void delete_module(plugin::Module *module)
 
476
static void plugin_del(plugin::Handle *plugin)
285
477
{
 
478
  PluginRegistry &registry= PluginRegistry::getPluginRegistry();
 
479
  if (plugin->isInited)
 
480
  {
 
481
    if (plugin->getManifest().status_vars)
 
482
    {
 
483
      remove_status_vars(plugin->getManifest().status_vars);
 
484
    }
 
485
 
 
486
    if (plugin->getManifest().deinit)
 
487
      plugin->getManifest().deinit(registry);
 
488
  }
 
489
 
286
490
  /* Free allocated strings before deleting the plugin. */
287
 
  plugin_vars_free_values(module->system_vars);
288
 
  module->isInited= false;
 
491
  plugin_vars_free_values(plugin->system_vars);
 
492
  if (plugin->plugin_dl)
 
493
    plugin_dl_del(&plugin->plugin_dl->dl);
 
494
  plugin->isInited= false;
289
495
  pthread_rwlock_wrlock(&LOCK_system_variables_hash);
290
 
  mysql_del_sys_var_chain(module->system_vars);
 
496
  mysql_del_sys_var_chain(plugin->system_vars);
291
497
  pthread_rwlock_unlock(&LOCK_system_variables_hash);
292
 
  delete module;
 
498
  delete plugin;
293
499
}
294
500
 
295
 
 
296
 
static void reap_plugins(plugin::Registry &registry)
 
501
static void reap_plugins(void)
297
502
{
298
 
  std::map<std::string, plugin::Module *>::const_iterator modules=
299
 
    registry.getModulesMap().begin();
300
 
 
301
 
  while (modules != registry.getModulesMap().end())
 
503
  size_t count;
 
504
  uint32_t idx;
 
505
  drizzled::plugin::Handle *plugin;
 
506
 
 
507
  count= plugin_array.elements;
 
508
 
 
509
  for (idx= 0; idx < count; idx++)
302
510
  {
303
 
    plugin::Module *module= (*modules).second;
304
 
    delete_module(module);
305
 
    ++modules;
 
511
    plugin= *dynamic_element(&plugin_array, idx, drizzled::plugin::Handle **);
 
512
    plugin_del(plugin);
306
513
  }
307
 
 
308
514
  drizzle_del_plugin_sysvar();
309
515
}
310
516
 
311
 
 
312
 
static void plugin_initialize_vars(plugin::Module *module)
 
517
static bool plugin_initialize(drizzled::plugin::Handle *plugin)
313
518
{
 
519
  assert(plugin->isInited == false);
 
520
 
 
521
  PluginRegistry &registry= PluginRegistry::getPluginRegistry();
 
522
  if (plugin->getManifest().init)
 
523
  {
 
524
    if (plugin->getManifest().init(registry))
 
525
    {
 
526
      errmsg_printf(ERRMSG_LVL_ERROR,
 
527
                    _("Plugin '%s' init function returned error.\n"),
 
528
                    plugin->getName().c_str());
 
529
      goto err;
 
530
    }
 
531
  }
 
532
  plugin->isInited= true;
 
533
 
 
534
  if (plugin->getManifest().status_vars)
 
535
  {
 
536
    add_status_vars(plugin->getManifest().status_vars); // add_status_vars makes a copy
 
537
  }
 
538
 
314
539
  /*
315
540
    set the plugin attribute of plugin's sys vars so they are pointing
316
541
    to the active plugin
317
542
  */
318
 
  if (module->system_vars)
 
543
  if (plugin->system_vars)
319
544
  {
320
 
    sys_var_pluginvar *var= module->system_vars->cast_pluginvar();
 
545
    sys_var_pluginvar *var= plugin->system_vars->cast_pluginvar();
321
546
    for (;;)
322
547
    {
323
 
      var->plugin= module;
 
548
      var->plugin= plugin;
324
549
      if (! var->getNext())
325
550
        break;
326
551
      var= var->getNext()->cast_pluginvar();
327
552
    }
328
553
  }
329
 
}
330
 
 
331
 
 
332
 
static bool plugin_initialize(plugin::Registry &registry,
333
 
                              plugin::Module *module)
334
 
{
335
 
  assert(module->isInited == false);
336
 
 
337
 
  plugin::Context loading_context(registry, module);
338
 
  if (module->getManifest().init)
339
 
  {
340
 
    if (module->getManifest().init(loading_context))
341
 
    {
342
 
      errmsg_printf(ERRMSG_LVL_ERROR,
343
 
                    _("Plugin '%s' init function returned error.\n"),
344
 
                    module->getName().c_str());
345
 
      return true;
346
 
    }
347
 
  }
348
 
  module->isInited= true;
349
 
 
350
554
 
351
555
  return false;
 
556
err:
 
557
  return true;
352
558
}
353
559
 
354
560
 
355
 
static unsigned char *get_bookmark_hash_key(const unsigned char *buff,
356
 
                                            size_t *length, bool)
 
561
extern "C" unsigned char *get_bookmark_hash_key(const unsigned char *, size_t *, bool);
 
562
 
 
563
 
 
564
unsigned char *get_bookmark_hash_key(const unsigned char *buff, size_t *length, bool)
357
565
{
358
566
  struct st_bookmark *var= (st_bookmark *)buff;
359
567
  *length= var->name_len + 1;
368
576
 
369
577
  Finally we initialize everything, aka the dynamic that have yet to initialize.
370
578
*/
371
 
bool plugin_init(plugin::Registry &registry,
372
 
                 int *argc, char **argv,
373
 
                 bool skip_init)
 
579
int plugin_init(int *argc, char **argv, int flags)
374
580
{
 
581
  uint32_t idx;
375
582
  plugin::Manifest **builtins;
376
583
  plugin::Manifest *manifest;
377
 
  plugin::Module *module;
378
 
  memory::Root tmp_root;
 
584
  plugin::Handle *handle;
 
585
  MEM_ROOT tmp_root;
379
586
 
380
587
  if (initialized)
381
 
    return false;
 
588
    return(0);
382
589
 
383
 
  init_alloc_root(&plugin_mem_root, 4096);
384
 
  init_alloc_root(&tmp_root, 4096);
 
590
  init_alloc_root(&plugin_mem_root, 4096, 4096);
 
591
  init_alloc_root(&tmp_root, 4096, 4096);
385
592
 
386
593
  if (hash_init(&bookmark_hash, &my_charset_bin, 16, 0, 0,
387
594
                  get_bookmark_hash_key, NULL, HASH_UNIQUE))
388
 
  {
389
 
    free_root(&tmp_root, MYF(0));
390
 
    return true;
391
 
  }
392
 
 
 
595
      goto err;
 
596
 
 
597
 
 
598
  if (my_init_dynamic_array(&plugin_dl_array,
 
599
                            sizeof(plugin::Library *),16,16) ||
 
600
      my_init_dynamic_array(&plugin_array,
 
601
                            sizeof(plugin::Handle *),16,16))
 
602
    goto err;
393
603
 
394
604
  initialized= 1;
395
605
 
398
608
  */
399
609
  for (builtins= drizzled_builtins; *builtins; builtins++)
400
610
  {
401
 
    manifest= *builtins;
402
 
    if (manifest->name != NULL)
 
611
    for (manifest= *builtins; manifest->name; manifest++)
403
612
    {
404
 
      module= new (std::nothrow) plugin::Module(manifest);
405
 
      if (module == NULL)
 
613
      handle= new (std::nothrow) plugin::Handle(manifest);
 
614
      if (handle == NULL)
406
615
        return true;
407
616
 
408
 
      free_root(&tmp_root, MYF(memory::MARK_BLOCKS_FREE));
409
 
      if (test_plugin_options(&tmp_root, module, argc, argv))
 
617
      free_root(&tmp_root, MYF(MY_MARK_BLOCKS_FREE));
 
618
      if (test_plugin_options(&tmp_root, handle, argc, argv))
410
619
        continue;
411
620
 
412
 
      registry.add(module);
413
 
 
414
 
      plugin_initialize_vars(module);
415
 
 
416
 
      if (! skip_init)
417
 
      {
418
 
        if (plugin_initialize(registry, module))
419
 
        {
420
 
          free_root(&tmp_root, MYF(0));
421
 
          return true;
422
 
        }
423
 
      }
 
621
      if (register_builtin(handle, &handle))
 
622
        goto err_unlock;
 
623
 
 
624
      if (plugin_initialize(handle))
 
625
        goto err_unlock;
 
626
 
424
627
    }
425
628
  }
426
629
 
427
630
 
428
 
  bool load_failed= false;
429
 
  vector<string> plugin_list;
430
 
  if (opt_plugin_load)
431
 
  {
432
 
    tokenize(opt_plugin_load, plugin_list, ",", true);
433
 
  }
434
 
  else
435
 
  {
436
 
    tokenize(opt_plugin_load_default, plugin_list, ",", true);
437
 
  }
438
 
  if (opt_plugin_add)
439
 
  {
440
 
    tokenize(opt_plugin_add, plugin_list, ",", true);
441
 
  }
442
 
 
443
 
  if (opt_plugin_remove)
444
 
  {
445
 
    vector<string> plugins_to_remove;
446
 
    tokenize(opt_plugin_remove, plugins_to_remove, ",", true);
447
 
    plugin_prune_list(plugin_list, plugins_to_remove);
448
 
  }
449
 
 
450
 
  /* Uniquify the list */
451
 
  const set<string> plugin_list_set(plugin_list.begin(), plugin_list.end());
452
 
  
453
631
  /* Register all dynamic plugins */
454
 
  load_failed= plugin_load_list(registry, &tmp_root, argc, argv,
455
 
                                plugin_list_set);
456
 
  if (load_failed)
 
632
  if (!(flags & PLUGIN_INIT_SKIP_DYNAMIC_LOADING))
457
633
  {
458
 
    free_root(&tmp_root, MYF(0));
459
 
    return true;
 
634
    if (opt_plugin_load)
 
635
      plugin_load_list(&tmp_root, argc, argv, opt_plugin_load);
460
636
  }
461
637
 
462
 
  if (skip_init)
463
 
  {
464
 
    free_root(&tmp_root, MYF(0));
465
 
    return false;
466
 
  }
 
638
  if (flags & PLUGIN_INIT_SKIP_INITIALIZATION)
 
639
    goto end;
467
640
 
468
641
  /*
469
642
    Now we initialize all remaining plugins
470
643
  */
471
 
  std::map<std::string, plugin::Module *>::const_iterator modules=
472
 
    registry.getModulesMap().begin();
473
 
    
474
 
  while (modules != registry.getModulesMap().end())
 
644
  for (idx= 0; idx < plugin_array.elements; idx++)
475
645
  {
476
 
    module= (*modules).second;
477
 
    ++modules;
478
 
    if (module->isInited == false)
 
646
    handle= *dynamic_element(&plugin_array, idx, plugin::Handle **);
 
647
    if (handle->isInited == false)
479
648
    {
480
 
      plugin_initialize_vars(module);
481
 
 
482
 
      if (plugin_initialize(registry, module))
483
 
        delete_module(module);
 
649
      if (plugin_initialize(handle))
 
650
        plugin_del(handle);
484
651
    }
485
652
  }
486
653
 
487
654
 
488
 
  free_root(&tmp_root, MYF(0));
489
 
 
490
 
  return false;
491
 
}
492
 
 
493
 
class PrunePlugin :
494
 
  public unary_function<string, bool>
495
 
{
496
 
  const string to_match;
497
 
  PrunePlugin();
498
 
  PrunePlugin& operator=(const PrunePlugin&);
499
 
public:
500
 
  explicit PrunePlugin(const string &match_in) :
501
 
    to_match(match_in)
502
 
  { }
503
 
 
504
 
  result_type operator()(const string &match_against)
505
 
  {
506
 
    return match_against == to_match;
507
 
  }
508
 
};
509
 
 
510
 
static void plugin_prune_list(vector<string> &plugin_list,
511
 
                              const vector<string> &plugins_to_remove)
512
 
{
513
 
  for (vector<string>::const_iterator iter= plugins_to_remove.begin();
514
 
       iter != plugins_to_remove.end();
515
 
       ++iter)
516
 
  {
517
 
    plugin_list.erase(remove_if(plugin_list.begin(),
518
 
                                plugin_list.end(),
519
 
                                PrunePlugin(*iter)),
520
 
                      plugin_list.end());
521
 
  }
522
 
}
 
655
end:
 
656
  free_root(&tmp_root, MYF(0));
 
657
 
 
658
  return(0);
 
659
 
 
660
err_unlock:
 
661
err:
 
662
  free_root(&tmp_root, MYF(0));
 
663
  return(1);
 
664
}
 
665
 
 
666
 
 
667
static bool register_builtin(plugin::Handle *tmp,
 
668
                             plugin::Handle **ptr)
 
669
{
 
670
 
 
671
  PluginRegistry &registry= PluginRegistry::getPluginRegistry();
 
672
 
 
673
  tmp->isInited= false;
 
674
  tmp->plugin_dl= 0;
 
675
 
 
676
  if (insert_dynamic(&plugin_array, (unsigned char*)&tmp))
 
677
    return(1);
 
678
 
 
679
  *ptr= *dynamic_element(&plugin_array, plugin_array.elements - 1,
 
680
                         plugin::Handle **);
 
681
 
 
682
  registry.add(*ptr);
 
683
 
 
684
  return(0);
 
685
}
 
686
 
523
687
 
524
688
/*
525
689
  called only by plugin_init()
526
690
*/
527
 
static bool plugin_load_list(plugin::Registry &registry,
528
 
                             memory::Root *tmp_root, int *argc, char **argv,
529
 
                             const set<string> &plugin_list)
 
691
static bool plugin_load_list(MEM_ROOT *tmp_root, int *argc, char **argv,
 
692
                             const char *list)
530
693
{
531
 
  plugin::Library *library= NULL;
532
 
 
533
 
  for (set<string>::const_iterator iter= plugin_list.begin();
534
 
       iter != plugin_list.end();
535
 
       ++iter)
 
694
  char buffer[FN_REFLEN];
 
695
  LEX_STRING name= {buffer, 0}, dl= {NULL, 0}, *str= &name;
 
696
  plugin::Library *plugin_dl;
 
697
  plugin::Manifest *plugin;
 
698
  char *p= buffer;
 
699
  while (list)
536
700
  {
537
 
    const string plugin_name(*iter);
538
 
    library= registry.addLibrary(plugin_name);
539
 
    if (library == NULL)
 
701
    if (p == buffer + sizeof(buffer) - 1)
540
702
    {
541
 
      errmsg_printf(ERRMSG_LVL_ERROR,
542
 
                    _("Couldn't load plugin library named '%s'.\n"),
543
 
                    plugin_name.c_str());
544
 
      return true;
 
703
      errmsg_printf(ERRMSG_LVL_ERROR, _("plugin-load parameter too long"));
 
704
      return(true);
545
705
    }
546
706
 
547
 
    free_root(tmp_root, MYF(memory::MARK_BLOCKS_FREE));
548
 
    if (plugin_add(registry, tmp_root, library, argc, argv))
549
 
    {
550
 
      registry.removeLibrary(plugin_name);
551
 
      errmsg_printf(ERRMSG_LVL_ERROR,
552
 
                    _("Couldn't load plugin named '%s'.\n"),
553
 
                    plugin_name.c_str());
554
 
      return true;
555
 
 
 
707
    switch ((*(p++)= *(list++))) {
 
708
    case '\0':
 
709
      list= NULL; /* terminate the loop */
 
710
      /* fall through */
 
711
    case ':':     /* can't use this as delimiter as it may be drive letter */
 
712
    case ';':
 
713
      str->str[str->length]= '\0';
 
714
      if (str == &name)  // load all plugins in named module
 
715
      {
 
716
        if (!name.length)
 
717
        {
 
718
          p--;    /* reset pointer */
 
719
          continue;
 
720
        }
 
721
 
 
722
        dl= name;
 
723
        if ((plugin_dl= plugin_dl_add(&dl, REPORT_TO_LOG)))
 
724
        {
 
725
          for (plugin= plugin_dl->plugins; plugin->name; plugin++)
 
726
          {
 
727
            name.str= (char *) plugin->name;
 
728
            name.length= strlen(name.str);
 
729
 
 
730
            free_root(tmp_root, MYF(MY_MARK_BLOCKS_FREE));
 
731
            if (plugin_add(tmp_root, &name, &dl, argc, argv, REPORT_TO_LOG))
 
732
              goto error;
 
733
          }
 
734
          plugin_dl_del(&dl); // reduce ref count
 
735
        }
 
736
      }
 
737
      else
 
738
      {
 
739
        free_root(tmp_root, MYF(MY_MARK_BLOCKS_FREE));
 
740
        if (plugin_add(tmp_root, &name, &dl, argc, argv, REPORT_TO_LOG))
 
741
          goto error;
 
742
      }
 
743
      name.length= dl.length= 0;
 
744
      dl.str= NULL; name.str= p= buffer;
 
745
      str= &name;
 
746
      continue;
 
747
    case '=':
 
748
    case '#':
 
749
      if (str == &name)
 
750
      {
 
751
        name.str[name.length]= '\0';
 
752
        str= &dl;
 
753
        str->str= p;
 
754
        continue;
 
755
      }
 
756
    default:
 
757
      str->length++;
 
758
      continue;
556
759
    }
557
760
  }
558
 
  return false;
 
761
  return(false);
 
762
error:
 
763
  errmsg_printf(ERRMSG_LVL_ERROR, _("Couldn't load plugin named '%s' with soname '%s'."),
 
764
                  name.str, dl.str);
 
765
  return(true);
559
766
}
560
767
 
561
768
 
562
 
void plugin_shutdown(plugin::Registry &registry)
 
769
void plugin_shutdown(void)
563
770
{
 
771
  uint32_t idx;
 
772
  size_t count= plugin_array.elements;
 
773
  vector<plugin::Handle *> plugins;
 
774
  vector<plugin::Library *> dl;
564
775
 
565
776
  if (initialized)
566
777
  {
567
778
    reap_needed= true;
568
779
 
569
 
    reap_plugins(registry);
 
780
    reap_plugins();
570
781
    unlock_variables(NULL, &global_system_variables);
571
782
    unlock_variables(NULL, &max_system_variables);
572
783
 
578
789
 
579
790
  /* Dispose of the memory */
580
791
 
 
792
  delete_dynamic(&plugin_array);
 
793
 
 
794
  count= plugin_dl_array.elements;
 
795
  dl.reserve(count);
 
796
  for (idx= 0; idx < count; idx++)
 
797
    dl.push_back(*dynamic_element(&plugin_dl_array, idx,
 
798
                 plugin::Library **));
 
799
  for (idx= 0; idx < count; idx++)
 
800
    free_plugin_mem(dl[idx]);
 
801
  delete_dynamic(&plugin_dl_array);
 
802
 
581
803
  hash_free(&bookmark_hash);
582
804
  free_root(&plugin_mem_root, MYF(0));
583
805
 
592
814
#define DRIZZLE_SYSVAR_NAME(name) name
593
815
#define PLUGIN_VAR_TYPEMASK 0x007f
594
816
 
595
 
static const uint32_t EXTRA_OPTIONS= 1; /* handle the NULL option */
 
817
#define EXTRA_OPTIONS 3 /* options for: 'foo', 'plugin-foo' and NULL */
596
818
 
597
819
typedef DECLARE_DRIZZLE_SYSVAR_BASIC(sysvar_bool_t, bool);
598
820
typedef DECLARE_DRIZZLE_SessionVAR_BASIC(sessionvar_bool_t, bool);
599
821
typedef DECLARE_DRIZZLE_SYSVAR_BASIC(sysvar_str_t, char *);
600
822
typedef DECLARE_DRIZZLE_SessionVAR_BASIC(sessionvar_str_t, char *);
601
823
 
 
824
typedef DECLARE_DRIZZLE_SYSVAR_TYPELIB(sysvar_enum_t, unsigned long);
602
825
typedef DECLARE_DRIZZLE_SessionVAR_TYPELIB(sessionvar_enum_t, unsigned long);
 
826
typedef DECLARE_DRIZZLE_SYSVAR_TYPELIB(sysvar_set_t, uint64_t);
603
827
typedef DECLARE_DRIZZLE_SessionVAR_TYPELIB(sessionvar_set_t, uint64_t);
604
828
 
605
829
typedef DECLARE_DRIZZLE_SYSVAR_SIMPLE(sysvar_int_t, int);
623
847
  default variable data check and update functions
624
848
****************************************************************************/
625
849
 
626
 
static int check_func_bool(Session *, drizzle_sys_var *var,
627
 
                           void *save, drizzle_value *value)
 
850
static int check_func_bool(Session *, struct st_mysql_sys_var *var,
 
851
                           void *save, st_mysql_value *value)
628
852
{
629
853
  char buff[STRING_BUFFER_USUAL_SIZE];
630
854
  const char *strvalue= "NULL", *str;
648
872
      goto err;
649
873
    if (tmp > 1)
650
874
    {
651
 
      internal::llstr(tmp, buff);
 
875
      llstr(tmp, buff);
652
876
      strvalue= buff;
653
877
      goto err;
654
878
    }
662
886
}
663
887
 
664
888
 
665
 
static int check_func_int(Session *session, drizzle_sys_var *var,
666
 
                          void *save, drizzle_value *value)
 
889
static int check_func_int(Session *session, struct st_mysql_sys_var *var,
 
890
                          void *save, st_mysql_value *value)
667
891
{
668
892
  bool fixed;
669
893
  int64_t tmp;
670
 
  struct option options;
 
894
  struct my_option options;
671
895
  value->val_int(value, &tmp);
672
896
  plugin_opt_set_limits(&options, var);
673
897
 
682
906
}
683
907
 
684
908
 
685
 
static int check_func_long(Session *session, drizzle_sys_var *var,
686
 
                          void *save, drizzle_value *value)
 
909
static int check_func_long(Session *session, struct st_mysql_sys_var *var,
 
910
                          void *save, st_mysql_value *value)
687
911
{
688
912
  bool fixed;
689
913
  int64_t tmp;
690
 
  struct option options;
 
914
  struct my_option options;
691
915
  value->val_int(value, &tmp);
692
916
  plugin_opt_set_limits(&options, var);
693
917
 
702
926
}
703
927
 
704
928
 
705
 
static int check_func_int64_t(Session *session, drizzle_sys_var *var,
706
 
                               void *save, drizzle_value *value)
 
929
static int check_func_int64_t(Session *session, struct st_mysql_sys_var *var,
 
930
                               void *save, st_mysql_value *value)
707
931
{
708
932
  bool fixed;
709
933
  int64_t tmp;
710
 
  struct option options;
 
934
  struct my_option options;
711
935
  value->val_int(value, &tmp);
712
936
  plugin_opt_set_limits(&options, var);
713
937
 
721
945
                              var->name, (int64_t) tmp);
722
946
}
723
947
 
724
 
static int check_func_str(Session *session, drizzle_sys_var *,
725
 
                          void *save, drizzle_value *value)
 
948
static int check_func_str(Session *session, struct st_mysql_sys_var *,
 
949
                          void *save, st_mysql_value *value)
726
950
{
727
951
  char buff[STRING_BUFFER_USUAL_SIZE];
728
952
  const char *str;
736
960
}
737
961
 
738
962
 
739
 
static void update_func_bool(Session *, drizzle_sys_var *,
 
963
static int check_func_enum(Session *, struct st_mysql_sys_var *var,
 
964
                           void *save, st_mysql_value *value)
 
965
{
 
966
  char buff[STRING_BUFFER_USUAL_SIZE];
 
967
  const char *strvalue= "NULL", *str;
 
968
  TYPELIB *typelib;
 
969
  int64_t tmp;
 
970
  long result;
 
971
  int length;
 
972
 
 
973
  if (var->flags & PLUGIN_VAR_SessionLOCAL)
 
974
    typelib= ((sessionvar_enum_t*) var)->typelib;
 
975
  else
 
976
    typelib= ((sysvar_enum_t*) var)->typelib;
 
977
 
 
978
  if (value->value_type(value) == DRIZZLE_VALUE_TYPE_STRING)
 
979
  {
 
980
    length= sizeof(buff);
 
981
    if (!(str= value->val_str(value, buff, &length)))
 
982
      goto err;
 
983
    if ((result= (long)find_type(typelib, str, length, 1)-1) < 0)
 
984
    {
 
985
      strvalue= str;
 
986
      goto err;
 
987
    }
 
988
  }
 
989
  else
 
990
  {
 
991
    if (value->val_int(value, &tmp))
 
992
      goto err;
 
993
    if (tmp >= typelib->count)
 
994
    {
 
995
      llstr(tmp, buff);
 
996
      strvalue= buff;
 
997
      goto err;
 
998
    }
 
999
    result= (long) tmp;
 
1000
  }
 
1001
  *(long*)save= result;
 
1002
  return 0;
 
1003
err:
 
1004
  my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), var->name, strvalue);
 
1005
  return 1;
 
1006
}
 
1007
 
 
1008
 
 
1009
static int check_func_set(Session *, struct st_mysql_sys_var *var,
 
1010
                          void *save, st_mysql_value *value)
 
1011
{
 
1012
  char buff[STRING_BUFFER_USUAL_SIZE], *error= 0;
 
1013
  const char *strvalue= "NULL", *str;
 
1014
  TYPELIB *typelib;
 
1015
  uint64_t result;
 
1016
  uint32_t error_len;
 
1017
  bool not_used;
 
1018
  int length;
 
1019
 
 
1020
  if (var->flags & PLUGIN_VAR_SessionLOCAL)
 
1021
    typelib= ((sessionvar_set_t*) var)->typelib;
 
1022
  else
 
1023
    typelib= ((sysvar_set_t*)var)->typelib;
 
1024
 
 
1025
  if (value->value_type(value) == DRIZZLE_VALUE_TYPE_STRING)
 
1026
  {
 
1027
    length= sizeof(buff);
 
1028
    if (!(str= value->val_str(value, buff, &length)))
 
1029
      goto err;
 
1030
    result= find_set(typelib, str, length, NULL,
 
1031
                     &error, &error_len, &not_used);
 
1032
    if (error_len)
 
1033
    {
 
1034
      length= min((uint32_t)sizeof(buff), error_len);
 
1035
      strncpy(buff, error, length);
 
1036
      buff[length]= '\0';
 
1037
      strvalue= buff;
 
1038
      goto err;
 
1039
    }
 
1040
  }
 
1041
  else
 
1042
  {
 
1043
    if (value->val_int(value, (int64_t *)&result))
 
1044
      goto err;
 
1045
    if (unlikely((result >= (1UL << typelib->count)) &&
 
1046
                 (typelib->count < sizeof(long)*8)))
 
1047
    {
 
1048
      llstr(result, buff);
 
1049
      strvalue= buff;
 
1050
      goto err;
 
1051
    }
 
1052
  }
 
1053
  *(uint64_t*)save= result;
 
1054
  return 0;
 
1055
err:
 
1056
  my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), var->name, strvalue);
 
1057
  return 1;
 
1058
}
 
1059
 
 
1060
 
 
1061
static void update_func_bool(Session *, struct st_mysql_sys_var *,
740
1062
                             void *tgt, const void *save)
741
1063
{
742
1064
  *(bool *) tgt= *(int *) save ? 1 : 0;
743
1065
}
744
1066
 
745
1067
 
746
 
static void update_func_int(Session *, drizzle_sys_var *,
 
1068
static void update_func_int(Session *, struct st_mysql_sys_var *,
747
1069
                             void *tgt, const void *save)
748
1070
{
749
1071
  *(int *)tgt= *(int *) save;
750
1072
}
751
1073
 
752
1074
 
753
 
static void update_func_long(Session *, drizzle_sys_var *,
 
1075
static void update_func_long(Session *, struct st_mysql_sys_var *,
754
1076
                             void *tgt, const void *save)
755
1077
{
756
1078
  *(long *)tgt= *(long *) save;
757
1079
}
758
1080
 
759
1081
 
760
 
static void update_func_int64_t(Session *, drizzle_sys_var *,
 
1082
static void update_func_int64_t(Session *, struct st_mysql_sys_var *,
761
1083
                                 void *tgt, const void *save)
762
1084
{
763
1085
  *(int64_t *)tgt= *(uint64_t *) save;
764
1086
}
765
1087
 
766
1088
 
767
 
static void update_func_str(Session *, drizzle_sys_var *var,
 
1089
static void update_func_str(Session *, struct st_mysql_sys_var *var,
768
1090
                             void *tgt, const void *save)
769
1091
{
770
1092
  char *old= *(char **) tgt;
793
1115
{
794
1116
  sys_var *var;
795
1117
  sys_var_pluginvar *pi= NULL;
796
 
  plugin::Module *module;
 
1118
  plugin::Handle *plugin;
797
1119
 
798
1120
  pthread_rwlock_rdlock(&LOCK_system_variables_hash);
799
1121
  if ((var= intern_find_sys_var(str, length, false)) &&
800
1122
      (pi= var->cast_pluginvar()))
801
1123
  {
802
1124
    pthread_rwlock_unlock(&LOCK_system_variables_hash);
803
 
    if (!(module= pi->plugin))
 
1125
    if (!(plugin= pi->plugin))
804
1126
      var= NULL; /* failed to lock it, it must be uninstalling */
805
 
    else if (module->isInited == false)
 
1127
    else if (plugin->isInited == false)
806
1128
    {
807
1129
      var= NULL;
808
1130
    }
819
1141
  return(var);
820
1142
}
821
1143
 
822
 
static const string make_bookmark_name(const string &plugin, const char *name, int flags)
823
 
{
824
 
  /* Embed the flags into the first char of the string */
825
 
  string varname(1, static_cast<char>(flags & PLUGIN_VAR_TYPEMASK));
826
 
  varname.append(plugin);
827
 
  varname.push_back('_');
828
 
  varname.append(name);
829
 
 
830
 
  for (string::iterator p= varname.begin() + 1; p != varname.end(); ++p)
831
 
  {
832
 
    if (*p == '-')
833
 
    {
834
 
      *p= '_';
835
 
    }
836
 
  }
837
 
  return varname;
838
 
}
839
1144
 
840
1145
/*
841
1146
  called by register_var, construct_options and test_plugin_options.
842
1147
  Returns the 'bookmark' for the named variable.
843
1148
  LOCK_system_variables_hash should be at least read locked
844
1149
*/
845
 
static st_bookmark *find_bookmark(const string &plugin, const char *name, int flags)
 
1150
static st_bookmark *find_bookmark(const char *plugin, const char *name, int flags)
846
1151
{
847
1152
  st_bookmark *result= NULL;
 
1153
  uint32_t namelen, length, pluginlen= 0;
 
1154
  char *varname, *p;
848
1155
 
849
1156
  if (!(flags & PLUGIN_VAR_SessionLOCAL))
850
1157
    return NULL;
851
1158
 
852
 
  const string varname(make_bookmark_name(plugin, name, flags));
853
 
 
 
1159
  namelen= strlen(name);
 
1160
  if (plugin)
 
1161
    pluginlen= strlen(plugin) + 1;
 
1162
  length= namelen + pluginlen + 2;
 
1163
  varname= (char*) malloc(length);
 
1164
 
 
1165
  if (plugin)
 
1166
  {
 
1167
    sprintf(varname+1,"%s_%s",plugin,name);
 
1168
    for (p= varname + 1; *p; p++)
 
1169
      if (*p == '-')
 
1170
        *p= '_';
 
1171
  }
 
1172
  else
 
1173
    memcpy(varname + 1, name, namelen + 1);
 
1174
 
 
1175
  varname[0]= flags & PLUGIN_VAR_TYPEMASK;
854
1176
 
855
1177
  result= (st_bookmark*) hash_search(&bookmark_hash,
856
 
                                     (const unsigned char*) varname.c_str(), varname.size() - 1);
 
1178
                                     (const unsigned char*) varname, length - 1);
857
1179
 
 
1180
  free(varname);
858
1181
  return result;
859
1182
}
860
1183
 
864
1187
  returns null for non session-local variables.
865
1188
  Requires that a write lock is obtained on LOCK_system_variables_hash
866
1189
*/
867
 
static st_bookmark *register_var(const string &plugin, const char *name,
 
1190
static st_bookmark *register_var(const char *plugin, const char *name,
868
1191
                                 int flags)
869
1192
{
870
 
  if (!(flags & PLUGIN_VAR_SessionLOCAL))
871
 
    return NULL;
872
 
 
873
 
  uint32_t size= 0, offset, new_size;
 
1193
  uint32_t length= strlen(plugin) + strlen(name) + 3, size= 0, offset, new_size;
874
1194
  st_bookmark *result;
 
1195
  char *varname, *p;
 
1196
 
 
1197
  if (!(flags & PLUGIN_VAR_SessionLOCAL))
 
1198
    return NULL;
875
1199
 
876
1200
  switch (flags & PLUGIN_VAR_TYPEMASK) {
877
1201
  case PLUGIN_VAR_BOOL:
881
1205
    size= ALIGN_SIZE(sizeof(int));
882
1206
    break;
883
1207
  case PLUGIN_VAR_LONG:
 
1208
  case PLUGIN_VAR_ENUM:
884
1209
    size= ALIGN_SIZE(sizeof(long));
885
1210
    break;
886
1211
  case PLUGIN_VAR_LONGLONG:
 
1212
  case PLUGIN_VAR_SET:
887
1213
    size= ALIGN_SIZE(sizeof(uint64_t));
888
1214
    break;
889
1215
  case PLUGIN_VAR_STR:
894
1220
    return NULL;
895
1221
  };
896
1222
 
 
1223
  varname= ((char*) malloc(length));
 
1224
  sprintf(varname+1, "%s_%s", plugin, name);
 
1225
  for (p= varname + 1; *p; p++)
 
1226
    if (*p == '-')
 
1227
      *p= '_';
897
1228
 
898
 
  if (!(result= find_bookmark(plugin, name, flags)))
 
1229
  if (!(result= find_bookmark(NULL, varname + 1, flags)))
899
1230
  {
900
 
    const string varname(make_bookmark_name(plugin, name, flags));
901
 
 
902
 
    result= static_cast<st_bookmark*>(alloc_root(&plugin_mem_root,
903
 
                                      sizeof(struct st_bookmark) + varname.size() + 1));
904
 
    memset(result->key, 0, varname.size()+1);
905
 
    memcpy(result->key, varname.c_str(), varname.size());
906
 
    result->name_len= varname.size() - 2;
 
1231
    result= (st_bookmark*) alloc_root(&plugin_mem_root,
 
1232
                                      sizeof(struct st_bookmark) + length-1);
 
1233
    varname[0]= flags & PLUGIN_VAR_TYPEMASK;
 
1234
    memcpy(result->key, varname, length);
 
1235
    result->name_len= length - 2;
907
1236
    result->offset= -1;
908
1237
 
909
1238
    assert(size && !(size & (size-1))); /* must be power of 2 */
959
1288
      assert(0);
960
1289
    }
961
1290
  }
 
1291
  free(varname);
962
1292
  return result;
963
1293
}
964
1294
 
996
1326
    if (global_lock)
997
1327
      pthread_mutex_lock(&LOCK_global_system_variables);
998
1328
 
999
 
    //safe_mutex_assert_owner(&LOCK_global_system_variables);
 
1329
    safe_mutex_assert_owner(&LOCK_global_system_variables);
1000
1330
 
1001
1331
    memcpy(session->variables.dynamic_variables_ptr +
1002
1332
             session->variables.dynamic_variables_size,
1076
1406
  return (char **)intern_sys_var_ptr(a_session, offset, true);
1077
1407
}
1078
1408
 
 
1409
static uint64_t *mysql_sys_var_ptr_set(Session* a_session, int offset)
 
1410
{
 
1411
  return (uint64_t *)intern_sys_var_ptr(a_session, offset, true);
 
1412
}
 
1413
 
 
1414
static unsigned long *mysql_sys_var_ptr_enum(Session* a_session, int offset)
 
1415
{
 
1416
  return (unsigned long *)intern_sys_var_ptr(a_session, offset, true);
 
1417
}
 
1418
 
 
1419
 
1079
1420
void plugin_sessionvar_init(Session *session)
1080
1421
{
1081
1422
  session->variables.storage_engine= NULL;
1215
1556
    return SHOW_LONGLONG;
1216
1557
  case PLUGIN_VAR_STR:
1217
1558
    return SHOW_CHAR_PTR;
 
1559
  case PLUGIN_VAR_ENUM:
 
1560
  case PLUGIN_VAR_SET:
 
1561
    return SHOW_CHAR;
1218
1562
  default:
1219
1563
    assert(0);
1220
1564
    return SHOW_UNDEF;
1222
1566
}
1223
1567
 
1224
1568
 
1225
 
unsigned char* sys_var_pluginvar::real_value_ptr(Session *session, sql_var_t type)
 
1569
unsigned char* sys_var_pluginvar::real_value_ptr(Session *session, enum_var_type type)
1226
1570
{
1227
1571
  assert(session || (type == OPT_GLOBAL));
1228
1572
  if (plugin_var->flags & PLUGIN_VAR_SessionLOCAL)
1239
1583
TYPELIB* sys_var_pluginvar::plugin_var_typelib(void)
1240
1584
{
1241
1585
  switch (plugin_var->flags & (PLUGIN_VAR_TYPEMASK | PLUGIN_VAR_SessionLOCAL)) {
1242
 
  case PLUGIN_VAR_SessionLOCAL:
 
1586
  case PLUGIN_VAR_ENUM:
 
1587
    return ((sysvar_enum_t *)plugin_var)->typelib;
 
1588
  case PLUGIN_VAR_SET:
 
1589
    return ((sysvar_set_t *)plugin_var)->typelib;
 
1590
  case PLUGIN_VAR_ENUM | PLUGIN_VAR_SessionLOCAL:
1243
1591
    return ((sessionvar_enum_t *)plugin_var)->typelib;
 
1592
  case PLUGIN_VAR_SET | PLUGIN_VAR_SessionLOCAL:
 
1593
    return ((sessionvar_set_t *)plugin_var)->typelib;
1244
1594
  default:
1245
1595
    return NULL;
1246
1596
  }
1248
1598
}
1249
1599
 
1250
1600
 
1251
 
unsigned char* sys_var_pluginvar::value_ptr(Session *session, sql_var_t type, const LEX_STRING *)
 
1601
unsigned char* sys_var_pluginvar::value_ptr(Session *session, enum_var_type type, const LEX_STRING *)
1252
1602
{
1253
1603
  unsigned char* result;
1254
1604
 
1255
1605
  result= real_value_ptr(session, type);
1256
1606
 
 
1607
  if ((plugin_var->flags & PLUGIN_VAR_TYPEMASK) == PLUGIN_VAR_ENUM)
 
1608
    result= (unsigned char*) get_type(plugin_var_typelib(), *(ulong*)result);
 
1609
  else if ((plugin_var->flags & PLUGIN_VAR_TYPEMASK) == PLUGIN_VAR_SET)
 
1610
  {
 
1611
    char buffer[STRING_BUFFER_USUAL_SIZE];
 
1612
    String str(buffer, sizeof(buffer), system_charset_info);
 
1613
    TYPELIB *typelib= plugin_var_typelib();
 
1614
    uint64_t mask= 1, value= *(uint64_t*) result;
 
1615
    uint32_t i;
 
1616
 
 
1617
    str.length(0);
 
1618
    for (i= 0; i < typelib->count; i++, mask<<=1)
 
1619
    {
 
1620
      if (!(value & mask))
 
1621
        continue;
 
1622
      str.append(typelib->type_names[i], typelib->type_lengths[i]);
 
1623
      str.append(',');
 
1624
    }
 
1625
 
 
1626
    result= (unsigned char*) "";
 
1627
    if (str.length())
 
1628
      result= (unsigned char*) session->strmake(str.ptr(), str.length()-1);
 
1629
  }
1257
1630
  return result;
1258
1631
}
1259
1632
 
1274
1647
}
1275
1648
 
1276
1649
 
1277
 
void sys_var_pluginvar::set_default(Session *session, sql_var_t type)
 
1650
void sys_var_pluginvar::set_default(Session *session, enum_var_type type)
1278
1651
{
1279
1652
  const void *src;
1280
1653
  void *tgt;
1303
1676
        case PLUGIN_VAR_LONGLONG:
1304
1677
          src= &((sessionvar_uint64_t_t*) plugin_var)->def_val;
1305
1678
          break;
 
1679
        case PLUGIN_VAR_ENUM:
 
1680
          src= &((sessionvar_enum_t*) plugin_var)->def_val;
 
1681
          break;
 
1682
        case PLUGIN_VAR_SET:
 
1683
          src= &((sessionvar_set_t*) plugin_var)->def_val;
 
1684
          break;
1306
1685
        case PLUGIN_VAR_BOOL:
1307
1686
          src= &((sessionvar_bool_t*) plugin_var)->def_val;
1308
1687
          break;
1370
1749
  options->block_size= (long) (opt)->blk_sz
1371
1750
 
1372
1751
 
1373
 
void plugin_opt_set_limits(struct option *options,
1374
 
                                                                                                         const drizzle_sys_var *opt)
 
1752
static void plugin_opt_set_limits(struct my_option *options,
 
1753
                                  const struct st_mysql_sys_var *opt)
1375
1754
{
1376
1755
  options->sub_size= 0;
1377
1756
 
1396
1775
  case PLUGIN_VAR_LONGLONG | PLUGIN_VAR_UNSIGNED:
1397
1776
    OPTION_SET_LIMITS(GET_ULL, options, (sysvar_uint64_t_t*) opt);
1398
1777
    break;
 
1778
  case PLUGIN_VAR_ENUM:
 
1779
    options->var_type= GET_ENUM;
 
1780
    options->typelib= ((sysvar_enum_t*) opt)->typelib;
 
1781
    options->def_value= ((sysvar_enum_t*) opt)->def_val;
 
1782
    options->min_value= options->block_size= 0;
 
1783
    options->max_value= options->typelib->count - 1;
 
1784
    break;
 
1785
  case PLUGIN_VAR_SET:
 
1786
    options->var_type= GET_SET;
 
1787
    options->typelib= ((sysvar_set_t*) opt)->typelib;
 
1788
    options->def_value= ((sysvar_set_t*) opt)->def_val;
 
1789
    options->min_value= options->block_size= 0;
 
1790
    options->max_value= (1UL << options->typelib->count) - 1;
 
1791
    break;
1399
1792
  case PLUGIN_VAR_BOOL:
1400
1793
    options->var_type= GET_BOOL;
1401
1794
    options->def_value= ((sysvar_bool_t*) opt)->def_val;
1424
1817
  case PLUGIN_VAR_LONGLONG | PLUGIN_VAR_UNSIGNED | PLUGIN_VAR_SessionLOCAL:
1425
1818
    OPTION_SET_LIMITS(GET_ULL, options, (sessionvar_uint64_t_t*) opt);
1426
1819
    break;
 
1820
  case PLUGIN_VAR_ENUM | PLUGIN_VAR_SessionLOCAL:
 
1821
    options->var_type= GET_ENUM;
 
1822
    options->typelib= ((sessionvar_enum_t*) opt)->typelib;
 
1823
    options->def_value= ((sessionvar_enum_t*) opt)->def_val;
 
1824
    options->min_value= options->block_size= 0;
 
1825
    options->max_value= options->typelib->count - 1;
 
1826
    break;
 
1827
  case PLUGIN_VAR_SET | PLUGIN_VAR_SessionLOCAL:
 
1828
    options->var_type= GET_SET;
 
1829
    options->typelib= ((sessionvar_set_t*) opt)->typelib;
 
1830
    options->def_value= ((sessionvar_set_t*) opt)->def_val;
 
1831
    options->min_value= options->block_size= 0;
 
1832
    options->max_value= (1UL << options->typelib->count) - 1;
 
1833
    break;
1427
1834
  case PLUGIN_VAR_BOOL | PLUGIN_VAR_SessionLOCAL:
1428
1835
    options->var_type= GET_BOOL;
1429
1836
    options->def_value= ((sessionvar_bool_t*) opt)->def_val;
1443
1850
    options->arg_type= OPT_ARG;
1444
1851
}
1445
1852
 
1446
 
static int get_one_plugin_option(int, const struct option *, char *)
 
1853
extern "C" bool get_one_plugin_option(int optid, const struct my_option *,
 
1854
                                         char *);
 
1855
 
 
1856
bool get_one_plugin_option(int, const struct my_option *, char *)
1447
1857
{
1448
1858
  return 0;
1449
1859
}
1450
1860
 
1451
1861
 
1452
 
static int construct_options(memory::Root *mem_root, plugin::Module *tmp,
1453
 
                             option *options)
 
1862
static int construct_options(MEM_ROOT *mem_root, plugin::Handle *tmp,
 
1863
                             my_option *options, bool can_disable)
1454
1864
{
1455
 
  
1456
 
  int localoptionid= 256;
1457
 
  const string plugin_name(tmp->getManifest().name);
1458
 
 
1459
 
  size_t namelen= plugin_name.size(), optnamelen;
1460
 
 
 
1865
  const char *plugin_name= tmp->getManifest().name;
 
1866
  uint32_t namelen= strlen(plugin_name), optnamelen;
 
1867
  uint32_t buffer_length= namelen * 4 + (can_disable ? 75 : 10);
 
1868
  char *name= (char*) alloc_root(mem_root, buffer_length) + 1;
1461
1869
  char *optname, *p;
1462
1870
  int index= 0, offset= 0;
1463
 
  drizzle_sys_var *opt, **plugin_option;
 
1871
  st_mysql_sys_var *opt, **plugin_option;
1464
1872
  st_bookmark *v;
1465
1873
 
1466
 
  string name(plugin_name);
1467
 
  transform(name.begin(), name.end(), name.begin(), ::tolower);
1468
 
 
1469
 
  for (string::iterator iter= name.begin(); iter != name.end(); ++iter)
 
1874
  /* support --skip-plugin-foo syntax */
 
1875
  memcpy(name, plugin_name, namelen + 1);
 
1876
  my_casedn_str(&my_charset_utf8_general_ci, name);
 
1877
  sprintf(name+namelen+1, "plugin-%s", name);
 
1878
  /* Now we have namelen + 1 + 7 + namelen + 1 == namelen * 2 + 9. */
 
1879
 
 
1880
  for (p= name + namelen*2 + 8; p > name; p--)
 
1881
    if (*p == '_')
 
1882
      *p= '-';
 
1883
 
 
1884
  if (can_disable)
1470
1885
  {
1471
 
    if (*iter == '_')
1472
 
      *iter= '-';
 
1886
    sprintf(name+namelen*2+10,
 
1887
            "Enable %s plugin. Disable with --skip-%s (will save memory).",
 
1888
            plugin_name, name);
 
1889
    /*
 
1890
      Now we have namelen * 2 + 10 (one char unused) + 7 + namelen + 9 +
 
1891
      20 + namelen + 20 + 1 == namelen * 4 + 67.
 
1892
    */
 
1893
 
 
1894
    options[0].comment= name + namelen*2 + 10;
1473
1895
  }
1474
1896
 
 
1897
  options[1].name= (options[0].name= name) + namelen + 1;
 
1898
  options[0].id= options[1].id= 256; /* must be >255. dup id ok */
 
1899
  options[0].var_type= options[1].var_type= GET_BOOL;
 
1900
  options[0].arg_type= options[1].arg_type= NO_ARG;
 
1901
  options[0].def_value= options[1].def_value= true;
 
1902
  options[0].value= options[0].u_max_value=
 
1903
  options[1].value= options[1].u_max_value= (char**) (name - 1);
 
1904
  options+= 2;
 
1905
 
1475
1906
  /*
1476
1907
    Two passes as the 2nd pass will take pointer addresses for use
1477
1908
    by my_getopt and register_var() in the first pass uses realloc
1501
1932
    case PLUGIN_VAR_STR:
1502
1933
      (((sessionvar_str_t *)opt)->resolve)= mysql_sys_var_ptr_str;
1503
1934
      break;
 
1935
    case PLUGIN_VAR_ENUM:
 
1936
      (((sessionvar_enum_t *)opt)->resolve)= mysql_sys_var_ptr_enum;
 
1937
      break;
 
1938
    case PLUGIN_VAR_SET:
 
1939
      (((sessionvar_set_t *)opt)->resolve)= mysql_sys_var_ptr_set;
 
1940
      break;
1504
1941
    default:
1505
1942
      errmsg_printf(ERRMSG_LVL_ERROR, _("Unknown variable type code 0x%x in plugin '%s'."),
1506
 
                      opt->flags, plugin_name.c_str());
 
1943
                      opt->flags, plugin_name);
1507
1944
      return(-1);
1508
1945
    };
1509
1946
  }
1548
1985
          errmsg_printf(ERRMSG_LVL_WARN, _("Server variable %s of plugin %s was forced "
1549
1986
                            "to be read-only: string variable without "
1550
1987
                            "update_func and PLUGIN_VAR_MEMALLOC flag"),
1551
 
                            opt->name, plugin_name.c_str());
 
1988
                            opt->name, plugin_name);
1552
1989
        }
1553
1990
      }
1554
1991
      break;
 
1992
    case PLUGIN_VAR_ENUM:
 
1993
      if (!opt->check)
 
1994
        opt->check= check_func_enum;
 
1995
      if (!opt->update)
 
1996
        opt->update= update_func_long;
 
1997
      break;
 
1998
    case PLUGIN_VAR_SET:
 
1999
      if (!opt->check)
 
2000
        opt->check= check_func_set;
 
2001
      if (!opt->update)
 
2002
        opt->update= update_func_int64_t;
 
2003
      break;
1555
2004
    default:
1556
2005
      errmsg_printf(ERRMSG_LVL_ERROR, _("Unknown variable type code 0x%x in plugin '%s'."),
1557
 
                      opt->flags, plugin_name.c_str());
 
2006
                      opt->flags, plugin_name);
1558
2007
      return(-1);
1559
2008
    }
1560
2009
 
1565
2014
    if (!opt->name)
1566
2015
    {
1567
2016
      errmsg_printf(ERRMSG_LVL_ERROR, _("Missing variable name in plugin '%s'."),
1568
 
                    plugin_name.c_str());
 
2017
                      plugin_name);
1569
2018
      return(-1);
1570
2019
    }
1571
2020
 
1573
2022
    {
1574
2023
      optnamelen= strlen(opt->name);
1575
2024
      optname= (char*) alloc_root(mem_root, namelen + optnamelen + 2);
1576
 
      sprintf(optname, "%s-%s", name.c_str(), opt->name);
 
2025
      sprintf(optname, "%s-%s", name, opt->name);
1577
2026
      optnamelen= namelen + optnamelen + 1;
1578
2027
    }
1579
2028
    else
1582
2031
      if (!(v= find_bookmark(name, opt->name, opt->flags)))
1583
2032
      {
1584
2033
        errmsg_printf(ERRMSG_LVL_ERROR, _("Thread local variable '%s' not allocated "
1585
 
                      "in plugin '%s'."), opt->name, plugin_name.c_str());
 
2034
                        "in plugin '%s'."), opt->name, plugin_name);
1586
2035
        return(-1);
1587
2036
      }
1588
2037
 
1603
2052
    options->name= optname;
1604
2053
    options->comment= opt->comment;
1605
2054
    options->app_type= opt;
1606
 
    options->id= localoptionid++;
 
2055
    options->id= (options-1)->id + 1;
1607
2056
 
1608
2057
    plugin_opt_set_limits(options, opt);
1609
2058
 
1613
2062
    else
1614
2063
      options->value= options->u_max_value= *(char***) (opt + 1);
1615
2064
 
1616
 
    options++;
 
2065
    options[1]= options[0];
 
2066
    options[1].name= p= (char*) alloc_root(mem_root, optnamelen + 8);
 
2067
    options[1].comment= 0; // hidden
 
2068
    sprintf(p,"plugin-%s",optname);
 
2069
 
 
2070
    options+= 2;
1617
2071
  }
1618
2072
 
1619
2073
  return(0);
1620
2074
}
1621
2075
 
1622
2076
 
1623
 
static option *construct_help_options(memory::Root *mem_root, plugin::Module *p)
 
2077
static my_option *construct_help_options(MEM_ROOT *mem_root, plugin::Handle *p)
1624
2078
{
1625
 
  drizzle_sys_var **opt;
1626
 
  option *opts;
 
2079
  st_mysql_sys_var **opt;
 
2080
  my_option *opts;
 
2081
  bool can_disable;
1627
2082
  uint32_t count= EXTRA_OPTIONS;
1628
2083
 
1629
 
  for (opt= p->getManifest().system_vars; opt && *opt; opt++, count++) {};
 
2084
  for (opt= p->getManifest().system_vars; opt && *opt; opt++, count+= 2) {};
1630
2085
 
1631
 
  opts= (option*)alloc_root(mem_root, (sizeof(option) * count));
 
2086
  opts= (my_option*)alloc_root(mem_root, (sizeof(my_option) * count));
1632
2087
  if (opts == NULL)
1633
2088
    return NULL;
1634
2089
 
1635
 
  memset(opts, 0, sizeof(option) * count);
1636
 
 
1637
 
  if (construct_options(mem_root, p, opts))
 
2090
  memset(opts, 0, sizeof(my_option) * count);
 
2091
 
 
2092
  if ((my_strcasecmp(&my_charset_utf8_general_ci, p->getName().c_str(), "MyISAM") == 0))
 
2093
    can_disable= false;
 
2094
  else if ((my_strcasecmp(&my_charset_utf8_general_ci, p->getName().c_str(), "MEMORY") == 0))
 
2095
    can_disable= false;
 
2096
  else
 
2097
    can_disable= true;
 
2098
 
 
2099
 
 
2100
  if (construct_options(mem_root, p, opts, can_disable))
1638
2101
    return NULL;
1639
2102
 
1640
2103
  return(opts);
1669
2132
  NOTE:
1670
2133
    Requires that a write-lock is held on LOCK_system_variables_hash
1671
2134
*/
1672
 
static int test_plugin_options(memory::Root *tmp_root, plugin::Module *tmp,
 
2135
static int test_plugin_options(MEM_ROOT *tmp_root, plugin::Handle *tmp,
1673
2136
                               int *argc, char **argv)
1674
2137
{
1675
2138
  struct sys_var_chain chain= { NULL, NULL };
1676
 
  drizzle_sys_var **opt;
1677
 
  option *opts= NULL;
 
2139
  bool can_disable;
 
2140
  st_mysql_sys_var **opt;
 
2141
  my_option *opts= NULL;
1678
2142
  int error;
1679
 
  drizzle_sys_var *o;
 
2143
  st_mysql_sys_var *o;
1680
2144
  struct st_bookmark *var;
1681
2145
  uint32_t len, count= EXTRA_OPTIONS;
1682
2146
 
1683
2147
  for (opt= tmp->getManifest().system_vars; opt && *opt; opt++)
1684
 
    count++;
 
2148
    count+= 2; /* --{plugin}-{optname} and --plugin-{plugin}-{optname} */
1685
2149
 
 
2150
  if ((my_strcasecmp(&my_charset_utf8_general_ci, tmp->getName().c_str(), "MyISAM") == 0))
 
2151
    can_disable= false;
 
2152
  else if ((my_strcasecmp(&my_charset_utf8_general_ci, tmp->getName().c_str(), "MEMORY") == 0))
 
2153
    can_disable= false;
 
2154
  else
 
2155
    can_disable= true;
1686
2156
 
1687
2157
  if (count > EXTRA_OPTIONS || (*argc > 1))
1688
2158
  {
1689
 
    if (!(opts= (option*) alloc_root(tmp_root, sizeof(option) * count)))
 
2159
    if (!(opts= (my_option*) alloc_root(tmp_root, sizeof(my_option) * count)))
1690
2160
    {
1691
2161
      errmsg_printf(ERRMSG_LVL_ERROR, _("Out of memory for plugin '%s'."), tmp->getName().c_str());
1692
2162
      return(-1);
1693
2163
    }
1694
 
    memset(opts, 0, sizeof(option) * count);
 
2164
    memset(opts, 0, sizeof(my_option) * count);
1695
2165
 
1696
 
    if (construct_options(tmp_root, tmp, opts))
 
2166
    if (construct_options(tmp_root, tmp, opts, can_disable))
1697
2167
    {
1698
2168
      errmsg_printf(ERRMSG_LVL_ERROR, _("Bad options for plugin '%s'."), tmp->getName().c_str());
1699
2169
      return(-1);
1719
2189
      if (((o= *opt)->flags & PLUGIN_VAR_NOSYSVAR))
1720
2190
        continue;
1721
2191
 
1722
 
      if ((var= find_bookmark(tmp->getName(), o->name, o->flags)))
 
2192
      if ((var= find_bookmark(tmp->getName().c_str(), o->name, o->flags)))
1723
2193
        v= new sys_var_pluginvar(var->key + 1, o);
1724
2194
      else
1725
2195
      {
1776
2246
class OptionCmp
1777
2247
{
1778
2248
public:
1779
 
  bool operator() (const option &a, const option &b)
 
2249
  bool operator() (const my_option &a, const my_option &b)
1780
2250
  {
1781
2251
    return my_strcasecmp(&my_charset_utf8_general_ci, a.name, b.name);
1782
2252
  }
1783
2253
};
1784
2254
 
1785
2255
 
1786
 
void my_print_help_inc_plugins(option *main_options)
 
2256
void my_print_help_inc_plugins(my_option *main_options)
1787
2257
{
1788
 
  plugin::Registry &registry= plugin::Registry::singleton();
1789
 
  vector<option> all_options;
1790
 
  plugin::Module *p;
1791
 
  memory::Root mem_root;
1792
 
  option *opt= NULL;
 
2258
  vector<my_option> all_options;
 
2259
  plugin::Handle *p;
 
2260
  MEM_ROOT mem_root;
 
2261
  my_option *opt= NULL;
1793
2262
 
1794
 
  init_alloc_root(&mem_root, 4096);
 
2263
  init_alloc_root(&mem_root, 4096, 4096);
1795
2264
 
1796
2265
  if (initialized)
1797
 
  {
1798
 
    std::map<std::string, plugin::Module *>::const_iterator modules=
1799
 
      registry.getModulesMap().begin();
1800
 
    
1801
 
    while (modules != registry.getModulesMap().end())
 
2266
    for (uint32_t idx= 0; idx < plugin_array.elements; idx++)
1802
2267
    {
1803
 
      p= (*modules).second;
1804
 
      ++modules;
 
2268
      p= *dynamic_element(&plugin_array, idx, plugin::Handle **);
1805
2269
 
1806
2270
      if (p->getManifest().system_vars == NULL)
1807
2271
        continue;
1820
2284
        }
1821
2285
      }
1822
2286
    }
1823
 
  }
1824
2287
 
1825
2288
  for (;main_options->id; main_options++)
1826
2289
  {
1831
2294
  }
1832
2295
 
1833
2296
  /** 
1834
 
   * @TODO: Fix the option building so that it doens't break sort
 
2297
   * @TODO: Fix the my_option building so that it doens't break sort
1835
2298
   *
1836
2299
   * sort(all_options.begin(), all_options.end(), OptionCmp());
1837
2300
   */
1846
2309
 
1847
2310
}
1848
2311
 
1849
 
} /* namespace drizzled */