← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/loader.cc

  • Committer: Brian Aker
  • Date: 2009-12-03 01:17:53 UTC
  • mto: (1237.3.2 push)
  • mto: This revision was merged to the branch mainline in revision 1238.
  • Revision ID: brian@gaz-20091203011753-159h2no5m5c5dt9b
Small cleanups, did in MERGE table only engine flag.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/loader.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
17
 
18
18
#include <dlfcn.h>
19
19
 
22
22
#include <map>
23
23
#include <algorithm>
24
24
 
25
 
#include "drizzled/option.h"
26
 
#include "drizzled/my_hash.h"
27
 
#include "drizzled/internal/m_string.h"
 
25
#include "mysys/my_getopt.h"
 
26
#include "mysys/hash.h"
28
27
 
29
 
#include "drizzled/plugin.h"
30
 
#include "drizzled/plugin/load_list.h"
 
28
#include "drizzled/plugin/config.h"
31
29
#include "drizzled/sql_parse.h"
32
30
#include "drizzled/show.h"
33
31
#include "drizzled/cursor.h"
38
36
#include "drizzled/error.h"
39
37
#include "drizzled/gettext.h"
40
38
#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"
 
39
 
45
40
 
46
41
/* FreeBSD 2.2.2 does not define RTLD_NOW) */
47
42
#ifndef RTLD_NOW
49
44
#endif
50
45
 
51
46
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[]=
 
47
using namespace drizzled;
 
48
 
 
49
typedef plugin::Manifest builtin_plugin[];
 
50
extern builtin_plugin PANDORA_BUILTIN_LIST;
 
51
static plugin::Manifest *drizzled_builtins[]=
56
52
{
57
53
  PANDORA_BUILTIN_LIST, NULL
58
54
};
59
55
 
60
 
namespace drizzled
61
 
{
62
 
 
63
 
 
64
56
class sys_var_pluginvar;
65
57
static vector<sys_var_pluginvar *> plugin_sysvar_vec;
66
58
 
67
59
char *opt_plugin_add= NULL;
68
 
char *opt_plugin_remove= NULL;
69
60
char *opt_plugin_load= NULL;
 
61
const char *opt_plugin_load_default= PANDORA_PLUGIN_LIST;
70
62
char *opt_plugin_dir_ptr;
71
63
char opt_plugin_dir[FN_REFLEN];
72
 
const char *opt_plugin_load_default= PANDORA_PLUGIN_LIST;
 
64
static const char *plugin_declarations_sym= "_drizzled_plugin_declaration_";
73
65
 
74
66
/* Note that 'int version' must be the first field of every plugin
75
67
   sub-structure (plugin->info).
77
69
 
78
70
static bool initialized= false;
79
71
 
 
72
static DYNAMIC_ARRAY plugin_dl_array;
 
73
static DYNAMIC_ARRAY module_array;
80
74
 
81
75
static bool reap_needed= false;
82
76
 
84
78
  write-lock on LOCK_system_variables_hash is required before modifying
85
79
  the following variables/structures
86
80
*/
87
 
static memory::Root plugin_mem_root;
 
81
static MEM_ROOT plugin_mem_root;
88
82
static uint32_t global_variables_dynamic_size= 0;
89
83
static HASH bookmark_hash;
90
84
 
93
87
  hidden part of opaque value passed to variable check functions.
94
88
  Used to provide a object-like structure to non C++ consumers.
95
89
*/
96
 
struct st_item_value_holder : public drizzle_value
 
90
struct st_item_value_holder : public st_mysql_value
97
91
{
98
92
  Item *item;
99
93
};
120
114
 
121
115
 
122
116
/*
 
117
  skeleton of a plugin variable - portion of structure common to all.
 
118
*/
 
119
struct st_mysql_sys_var
 
120
{
 
121
  DRIZZLE_PLUGIN_VAR_HEADER;
 
122
};
 
123
 
 
124
 
 
125
/*
123
126
  sys_var class for access to all plugin variables visible to the user
124
127
*/
125
128
class sys_var_pluginvar: public sys_var
126
129
{
127
130
public:
128
131
  plugin::Module *plugin;
129
 
  drizzle_sys_var *plugin_var;
 
132
  struct st_mysql_sys_var *plugin_var;
130
133
 
131
134
  sys_var_pluginvar(const std::string name_arg,
132
 
                    drizzle_sys_var *plugin_var_arg)
 
135
                    struct st_mysql_sys_var *plugin_var_arg)
133
136
    :sys_var(name_arg), plugin_var(plugin_var_arg) {}
134
137
  sys_var_pluginvar *cast_pluginvar() { return this; }
135
138
  bool is_readonly() const { return plugin_var->flags & PLUGIN_VAR_READONLY; }
136
 
  bool check_type(sql_var_t type)
 
139
  bool check_type(enum_var_type type)
137
140
  { return !(plugin_var->flags & PLUGIN_VAR_SessionLOCAL) && type != OPT_GLOBAL; }
138
141
  bool check_update_type(Item_result type);
139
142
  SHOW_TYPE show_type();
140
 
  unsigned char* real_value_ptr(Session *session, sql_var_t type);
 
143
  unsigned char* real_value_ptr(Session *session, enum_var_type type);
141
144
  TYPELIB* plugin_var_typelib(void);
142
 
  unsigned char* value_ptr(Session *session, sql_var_t type,
 
145
  unsigned char* value_ptr(Session *session, enum_var_type type,
143
146
                           const LEX_STRING *base);
144
147
  bool check(Session *session, set_var *var);
145
 
  bool check_default(sql_var_t)
 
148
  bool check_default(enum_var_type)
146
149
    { return is_readonly(); }
147
 
  void set_default(Session *session, sql_var_t);
 
150
  void set_default(Session *session, enum_var_type);
148
151
  bool update(Session *session, set_var *var);
149
152
};
150
153
 
151
154
 
152
155
/* prototypes */
153
 
static void plugin_prune_list(vector<string> &plugin_list,
154
 
                              const vector<string> &plugins_to_remove);
155
156
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 *,
 
157
                             MEM_ROOT *tmp_root, int *argc, char **argv,
 
158
                             const char *list);
 
159
static int test_plugin_options(MEM_ROOT *, plugin::Module *,
159
160
                               int *, char **);
 
161
static bool register_builtin(plugin::Registry &registry,
 
162
                             plugin::Module *,
 
163
                             plugin::Module **);
160
164
static void unlock_variables(Session *session, struct system_variables *vars);
161
165
static void cleanup_variables(Session *session, struct system_variables *vars);
162
166
static void plugin_vars_free_values(sys_var *vars);
 
167
static void plugin_opt_set_limits(struct my_option *options,
 
168
                                  const struct st_mysql_sys_var *opt);
 
169
static void reap_plugins(plugin::Registry &plugins);
 
170
 
163
171
 
164
172
/* declared in set_var.cc */
165
173
extern sys_var *intern_find_sys_var(const char *str, uint32_t length, bool no_error);
177
185
  Value type thunks, allows the C world to play in the C++ world
178
186
****************************************************************************/
179
187
 
180
 
static int item_value_type(drizzle_value *value)
 
188
static int item_value_type(struct st_mysql_value *value)
181
189
{
182
190
  switch (((st_item_value_holder*)value)->item->result_type()) {
183
191
  case INT_RESULT:
189
197
  }
190
198
}
191
199
 
192
 
static const char *item_val_str(drizzle_value *value,
 
200
static const char *item_val_str(struct st_mysql_value *value,
193
201
                                char *buffer, int *length)
194
202
{
195
203
  String str(buffer, *length, system_charset_info), *res;
207
215
}
208
216
 
209
217
 
210
 
static int item_val_int(drizzle_value *value, int64_t *buf)
 
218
static int item_val_int(struct st_mysql_value *value, int64_t *buf)
211
219
{
212
220
  Item *item= ((st_item_value_holder*)value)->item;
213
221
  *buf= item->val_int();
217
225
}
218
226
 
219
227
 
220
 
static int item_val_real(drizzle_value *value, double *buf)
 
228
static int item_val_real(struct st_mysql_value *value, double *buf)
221
229
{
222
230
  Item *item= ((st_item_value_holder*)value)->item;
223
231
  *buf= item->val_real();
231
239
  Plugin support code
232
240
****************************************************************************/
233
241
 
234
 
 
 
242
static plugin::Library *plugin_dl_find(const LEX_STRING *dl)
 
243
{
 
244
  uint32_t i;
 
245
  plugin::Library *tmp;
 
246
 
 
247
  for (i= 0; i < plugin_dl_array.elements; i++)
 
248
  {
 
249
    tmp= *dynamic_element(&plugin_dl_array, i, plugin::Library **);
 
250
    if (! my_strnncoll(files_charset_info,
 
251
                       (const unsigned char *)dl->str, dl->length,
 
252
                       (const unsigned char *)tmp->dl.str, tmp->dl.length))
 
253
      return(tmp);
 
254
  }
 
255
  return(0);
 
256
}
 
257
 
 
258
static plugin::Library *plugin_dl_insert_or_reuse(plugin::Library *plugin_dl)
 
259
{
 
260
  uint32_t i;
 
261
  plugin::Library *tmp;
 
262
 
 
263
  for (i= 0; i < plugin_dl_array.elements; i++)
 
264
  {
 
265
    tmp= *dynamic_element(&plugin_dl_array, i, plugin::Library **);
 
266
    {
 
267
      memcpy(tmp, plugin_dl, sizeof(plugin::Library));
 
268
      return(tmp);
 
269
    }
 
270
  }
 
271
  if (insert_dynamic(&plugin_dl_array, (unsigned char*)&plugin_dl))
 
272
    return(0);
 
273
  tmp= *dynamic_element(&plugin_dl_array, plugin_dl_array.elements - 1,
 
274
                        plugin::Library **)=
 
275
      (plugin::Library *) memdup_root(&plugin_mem_root,
 
276
                                      (unsigned char*)plugin_dl,
 
277
                                      sizeof(plugin::Library));
 
278
  return(tmp);
 
279
}
 
280
 
 
281
static inline void free_plugin_mem(plugin::Library *p)
 
282
{
 
283
  if (p->handle)
 
284
    dlclose(p->handle);
 
285
  free(p->dl.str);
 
286
}
 
287
 
 
288
 
 
289
static plugin::Library *plugin_dl_add(const LEX_STRING *dl)
 
290
{
 
291
  string dlpath;
 
292
  uint32_t plugin_dir_len;
 
293
  plugin::Library *tmp, plugin_dl;
 
294
  void *sym;
 
295
  plugin_dir_len= strlen(opt_plugin_dir);
 
296
  dlpath.reserve(FN_REFLEN);
 
297
  /*
 
298
    Ensure that the dll doesn't have a path.
 
299
    This is done to ensure that only approved libraries from the
 
300
    plugin directory are used (to make this even remotely secure).
 
301
  */
 
302
  if (strchr(dl->str, FN_LIBCHAR) ||
 
303
      check_string_char_length((LEX_STRING *) dl, "", NAME_CHAR_LEN,
 
304
                               system_charset_info, 1) ||
 
305
      plugin_dir_len + dl->length + 1 >= FN_REFLEN)
 
306
  {
 
307
    errmsg_printf(ERRMSG_LVL_ERROR, "%s",ER(ER_UDF_NO_PATHS));
 
308
    return NULL;
 
309
  }
 
310
  /* If this dll is already loaded just increase ref_count. */
 
311
  if ((tmp= plugin_dl_find(dl)))
 
312
  {
 
313
    return(tmp);
 
314
  }
 
315
  memset(&plugin_dl, 0, sizeof(plugin_dl));
 
316
  /* Compile dll path */
 
317
  dlpath.append(opt_plugin_dir);
 
318
  dlpath.append("/");
 
319
  dlpath.append("lib");
 
320
  dlpath.append(dl->str);
 
321
  dlpath.append("_plugin.so");
 
322
  /* Open new dll handle */
 
323
  if (!(plugin_dl.handle= dlopen(dlpath.c_str(), RTLD_NOW|RTLD_GLOBAL)))
 
324
  {
 
325
    const char *errmsg= dlerror();
 
326
    uint32_t dlpathlen= dlpath.length();
 
327
    if (!dlpath.compare(0, dlpathlen, errmsg))
 
328
    { // if errmsg starts from dlpath, trim this prefix.
 
329
      errmsg+=dlpathlen;
 
330
      if (*errmsg == ':') errmsg++;
 
331
      if (*errmsg == ' ') errmsg++;
 
332
    }
 
333
    errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_CANT_OPEN_LIBRARY), dlpath.c_str(), errno, errmsg);
 
334
 
 
335
    // This is, in theory, should cause dlerror() to deallocate the error
 
336
    // message. Found this via Google'ing :)
 
337
    (void)dlerror();
 
338
 
 
339
    return NULL;
 
340
  }
 
341
 
 
342
  /* Find plugin declarations */
 
343
  if (!(sym= dlsym(plugin_dl.handle, plugin_declarations_sym)))
 
344
  {
 
345
    free_plugin_mem(&plugin_dl);
 
346
    errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_CANT_FIND_DL_ENTRY), plugin_declarations_sym);
 
347
    return NULL;
 
348
  }
 
349
 
 
350
  plugin_dl.plugins= static_cast<plugin::Manifest *>(sym);
 
351
 
 
352
  /* Duplicate and convert dll name */
 
353
  plugin_dl.dl.length= dl->length * files_charset_info->mbmaxlen + 1;
 
354
  if (! (plugin_dl.dl.str= (char*) calloc(plugin_dl.dl.length, sizeof(char))))
 
355
  {
 
356
    free_plugin_mem(&plugin_dl);
 
357
    errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_OUTOFMEMORY), plugin_dl.dl.length);
 
358
    return NULL;
 
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
    errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_OUTOFMEMORY),
 
366
                  sizeof(plugin::Library));
 
367
    return NULL;
 
368
  }
 
369
  return(tmp);
 
370
}
 
371
 
 
372
 
 
373
static void plugin_dl_del(const LEX_STRING *dl)
 
374
{
 
375
  uint32_t i;
 
376
 
 
377
  for (i= 0; i < plugin_dl_array.elements; i++)
 
378
  {
 
379
    plugin::Library *tmp= *dynamic_element(&plugin_dl_array, i,
 
380
                                           plugin::Library **);
 
381
    if (! my_strnncoll(files_charset_info,
 
382
                       (const unsigned char *)dl->str, dl->length,
 
383
                       (const unsigned char *)tmp->dl.str, tmp->dl.length))
 
384
    {
 
385
      /* Do not remove this element, unless no other plugin uses this dll. */
 
386
      {
 
387
        free_plugin_mem(tmp);
 
388
        memset(tmp, 0, sizeof(plugin::Library));
 
389
      }
 
390
      break;
 
391
    }
 
392
  }
 
393
  return;
 
394
}
 
395
 
 
396
 
 
397
 
 
398
static plugin::Module *plugin_insert_or_reuse(plugin::Module *module)
 
399
{
 
400
  if (insert_dynamic(&module_array, (unsigned char*)&module))
 
401
    return NULL;
 
402
  module= *dynamic_element(&module_array, module_array.elements - 1,
 
403
                           plugin::Module **);
 
404
  return module;
 
405
}
235
406
 
236
407
 
237
408
/*
238
409
  NOTE
239
410
    Requires that a write-lock is held on LOCK_system_variables_hash
240
411
*/
241
 
static bool plugin_add(plugin::Registry &registry, memory::Root *tmp_root,
242
 
                       plugin::Library *library,
 
412
static bool plugin_add(plugin::Registry &registry, MEM_ROOT *tmp_root,
 
413
                       const LEX_STRING *name, const LEX_STRING *dl,
243
414
                       int *argc, char **argv)
244
415
{
 
416
  plugin::Manifest *manifest;
245
417
  if (! initialized)
246
 
    return true;
 
418
    return(0);
247
419
 
248
 
  if (registry.find(library->getName()))
 
420
  if (registry.find(name))
249
421
  {
250
 
    errmsg_printf(ERRMSG_LVL_WARN, ER(ER_PLUGIN_EXISTS),
251
 
                  library->getName().c_str());
252
 
    return false;
 
422
    errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_UDF_EXISTS), name->str);
 
423
    return(true);
253
424
  }
 
425
  plugin::Library *library= plugin_dl_add(dl);
 
426
  if (library == NULL)
 
427
    return true;
254
428
 
255
429
  plugin::Module *tmp= NULL;
256
430
  /* 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;
 
431
  for (manifest= library->plugins; manifest->name; manifest++)
 
432
  {
 
433
    if (! my_strnncoll(system_charset_info,
 
434
                       (const unsigned char *)name->str, name->length,
 
435
                       (const unsigned char *)manifest->name,
 
436
                       strlen(manifest->name)))
 
437
    {
 
438
      tmp= new (std::nothrow) plugin::Module(manifest, library);
 
439
      if (tmp == NULL)
 
440
        return true;
 
441
 
 
442
      if (!test_plugin_options(tmp_root, tmp, argc, argv))
 
443
      {
 
444
        if ((tmp= plugin_insert_or_reuse(tmp)))
 
445
        {
 
446
          registry.add(tmp);
 
447
          init_alloc_root(&tmp->mem_root, 4096, 4096);
 
448
          return(false);
 
449
        }
 
450
        mysql_del_sys_var_chain(tmp->system_vars);
 
451
        goto err;
 
452
      }
 
453
      /* plugin was disabled */
 
454
      plugin_dl_del(dl);
 
455
      return(false);
 
456
    }
 
457
  }
 
458
  errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_CANT_FIND_DL_ENTRY), name->str);
 
459
err:
 
460
  plugin_dl_del(dl);
 
461
  return(true);
281
462
}
282
463
 
283
464
 
284
 
static void delete_module(plugin::Module *module)
 
465
static void delete_module(plugin::Registry &registry, plugin::Module *module)
285
466
{
 
467
  plugin::Manifest manifest= module->getManifest();
 
468
 
 
469
  if (module->isInited)
 
470
  {
 
471
    if (manifest.status_vars)
 
472
    {
 
473
      remove_status_vars(manifest.status_vars);
 
474
    }
 
475
 
 
476
    if (manifest.deinit)
 
477
      manifest.deinit(registry);
 
478
  }
 
479
 
286
480
  /* Free allocated strings before deleting the plugin. */
287
481
  plugin_vars_free_values(module->system_vars);
 
482
  if (module->plugin_dl)
 
483
    plugin_dl_del(&module->plugin_dl->dl);
288
484
  module->isInited= false;
289
485
  pthread_rwlock_wrlock(&LOCK_system_variables_hash);
290
486
  mysql_del_sys_var_chain(module->system_vars);
292
488
  delete module;
293
489
}
294
490
 
295
 
 
296
 
static void reap_plugins(plugin::Registry &registry)
 
491
static void reap_plugins(plugin::Registry &plugins)
297
492
{
298
 
  std::map<std::string, plugin::Module *>::const_iterator modules=
299
 
    registry.getModulesMap().begin();
300
 
 
301
 
  while (modules != registry.getModulesMap().end())
 
493
  size_t count;
 
494
  uint32_t idx;
 
495
  plugin::Module *module;
 
496
 
 
497
  count= module_array.elements;
 
498
 
 
499
  for (idx= 0; idx < count; idx++)
302
500
  {
303
 
    plugin::Module *module= (*modules).second;
304
 
    delete_module(module);
305
 
    ++modules;
 
501
    module= *dynamic_element(&module_array, idx, plugin::Module **);
 
502
    delete_module(plugins, module);
306
503
  }
307
 
 
308
504
  drizzle_del_plugin_sysvar();
309
505
}
310
506
 
311
507
 
312
508
static void plugin_initialize_vars(plugin::Module *module)
313
509
{
 
510
  if (module->getManifest().status_vars)
 
511
  {
 
512
    add_status_vars(module->getManifest().status_vars); // add_status_vars makes a copy
 
513
  }
 
514
 
314
515
  /*
315
516
    set the plugin attribute of plugin's sys vars so they are pointing
316
517
    to the active plugin
334
535
{
335
536
  assert(module->isInited == false);
336
537
 
337
 
  plugin::Context loading_context(registry, module);
 
538
  registry.setCurrentModule(module);
338
539
  if (module->getManifest().init)
339
540
  {
340
 
    if (module->getManifest().init(loading_context))
 
541
    if (module->getManifest().init(registry))
341
542
    {
342
543
      errmsg_printf(ERRMSG_LVL_ERROR,
343
544
                    _("Plugin '%s' init function returned error.\n"),
345
546
      return true;
346
547
    }
347
548
  }
 
549
  registry.clearCurrentModule();
348
550
  module->isInited= true;
349
551
 
350
552
 
352
554
}
353
555
 
354
556
 
355
 
static unsigned char *get_bookmark_hash_key(const unsigned char *buff,
356
 
                                            size_t *length, bool)
 
557
extern "C" unsigned char *get_bookmark_hash_key(const unsigned char *, size_t *, bool);
 
558
 
 
559
 
 
560
unsigned char *get_bookmark_hash_key(const unsigned char *buff, size_t *length, bool)
357
561
{
358
562
  struct st_bookmark *var= (st_bookmark *)buff;
359
563
  *length= var->name_len + 1;
368
572
 
369
573
  Finally we initialize everything, aka the dynamic that have yet to initialize.
370
574
*/
371
 
bool plugin_init(plugin::Registry &registry,
372
 
                 int *argc, char **argv,
373
 
                 bool skip_init)
 
575
int plugin_init(plugin::Registry &registry, int *argc, char **argv, int flags)
374
576
{
 
577
  uint32_t idx;
375
578
  plugin::Manifest **builtins;
376
579
  plugin::Manifest *manifest;
377
580
  plugin::Module *module;
378
 
  memory::Root tmp_root;
 
581
  MEM_ROOT tmp_root;
379
582
 
380
583
  if (initialized)
381
 
    return false;
 
584
    return(0);
382
585
 
383
 
  init_alloc_root(&plugin_mem_root, 4096);
384
 
  init_alloc_root(&tmp_root, 4096);
 
586
  init_alloc_root(&plugin_mem_root, 4096, 4096);
 
587
  init_alloc_root(&tmp_root, 4096, 4096);
385
588
 
386
589
  if (hash_init(&bookmark_hash, &my_charset_bin, 16, 0, 0,
387
590
                  get_bookmark_hash_key, NULL, HASH_UNIQUE))
388
 
  {
389
 
    free_root(&tmp_root, MYF(0));
390
 
    return true;
391
 
  }
392
 
 
 
591
      goto err;
 
592
 
 
593
 
 
594
  if (my_init_dynamic_array(&plugin_dl_array,
 
595
                            sizeof(plugin::Library *),16,16) ||
 
596
      my_init_dynamic_array(&module_array,
 
597
                            sizeof(plugin::Module *),16,16))
 
598
    goto err;
393
599
 
394
600
  initialized= 1;
395
601
 
398
604
  */
399
605
  for (builtins= drizzled_builtins; *builtins; builtins++)
400
606
  {
401
 
    manifest= *builtins;
402
 
    if (manifest->name != NULL)
 
607
    for (manifest= *builtins; manifest->name; manifest++)
403
608
    {
404
609
      module= new (std::nothrow) plugin::Module(manifest);
405
610
      if (module == NULL)
406
611
        return true;
407
612
 
408
 
      free_root(&tmp_root, MYF(memory::MARK_BLOCKS_FREE));
 
613
      free_root(&tmp_root, MYF(MY_MARK_BLOCKS_FREE));
409
614
      if (test_plugin_options(&tmp_root, module, argc, argv))
410
615
        continue;
411
616
 
412
 
      registry.add(module);
 
617
      if (register_builtin(registry, module, &module))
 
618
        goto err_unlock;
413
619
 
414
620
      plugin_initialize_vars(module);
415
621
 
416
 
      if (! skip_init)
 
622
      if (! (flags & PLUGIN_INIT_SKIP_INITIALIZATION))
417
623
      {
418
624
        if (plugin_initialize(registry, module))
419
 
        {
420
 
          free_root(&tmp_root, MYF(0));
421
 
          return true;
422
 
        }
 
625
          goto err_unlock;
423
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
    {
 
636
      plugin_load_list(registry, &tmp_root, argc, argv, opt_plugin_load);
 
637
    }
 
638
    else
 
639
    {
 
640
      string tmp_plugin_list(opt_plugin_load_default);
 
641
      if (opt_plugin_add)
 
642
      {
 
643
        tmp_plugin_list.push_back(',');
 
644
        tmp_plugin_list.append(opt_plugin_add);
 
645
      }
 
646
      plugin_load_list(registry, &tmp_root, argc, argv, tmp_plugin_list.c_str());
 
647
    }
460
648
  }
461
649
 
462
 
  if (skip_init)
463
 
  {
464
 
    free_root(&tmp_root, MYF(0));
465
 
    return false;
466
 
  }
 
650
  if (flags & PLUGIN_INIT_SKIP_INITIALIZATION)
 
651
    goto end;
467
652
 
468
653
  /*
469
654
    Now we initialize all remaining plugins
470
655
  */
471
 
  std::map<std::string, plugin::Module *>::const_iterator modules=
472
 
    registry.getModulesMap().begin();
473
 
    
474
 
  while (modules != registry.getModulesMap().end())
 
656
  for (idx= 0; idx < module_array.elements; idx++)
475
657
  {
476
 
    module= (*modules).second;
477
 
    ++modules;
 
658
    module= *dynamic_element(&module_array, idx, plugin::Module **);
478
659
    if (module->isInited == false)
479
660
    {
480
661
      plugin_initialize_vars(module);
481
662
 
482
663
      if (plugin_initialize(registry, module))
483
 
        delete_module(module);
 
664
        delete_module(registry, module);
484
665
    }
485
666
  }
486
667
 
487
668
 
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
 
}
 
669
end:
 
670
  free_root(&tmp_root, MYF(0));
 
671
 
 
672
  return(0);
 
673
 
 
674
err_unlock:
 
675
err:
 
676
  free_root(&tmp_root, MYF(0));
 
677
  return(1);
 
678
}
 
679
 
 
680
 
 
681
static bool register_builtin(plugin::Registry &registry,
 
682
                             plugin::Module *tmp,
 
683
                             plugin::Module **ptr)
 
684
{
 
685
 
 
686
  tmp->isInited= false;
 
687
  tmp->plugin_dl= 0;
 
688
 
 
689
  if (insert_dynamic(&module_array, (unsigned char*)&tmp))
 
690
    return(1);
 
691
 
 
692
  *ptr= *dynamic_element(&module_array, module_array.elements - 1,
 
693
                         plugin::Module **);
 
694
 
 
695
  registry.add(*ptr);
 
696
 
 
697
  return(0);
 
698
}
 
699
 
523
700
 
524
701
/*
525
702
  called only by plugin_init()
526
703
*/
527
 
static bool plugin_load_list(plugin::Registry &registry,
528
 
                             memory::Root *tmp_root, int *argc, char **argv,
529
 
                             const set<string> &plugin_list)
 
704
static bool plugin_load_list(plugin::Registry &plugins,
 
705
                             MEM_ROOT *tmp_root, int *argc, char **argv,
 
706
                             const char *list)
530
707
{
531
 
  plugin::Library *library= NULL;
532
 
 
533
 
  for (set<string>::const_iterator iter= plugin_list.begin();
534
 
       iter != plugin_list.end();
535
 
       ++iter)
 
708
  char buffer[FN_REFLEN];
 
709
  LEX_STRING name= {buffer, 0}, dl= {NULL, 0}, *str= &name;
 
710
  plugin::Library *plugin_dl;
 
711
  plugin::Manifest *plugin;
 
712
  char *p= buffer;
 
713
  while (list)
536
714
  {
537
 
    const string plugin_name(*iter);
538
 
    library= registry.addLibrary(plugin_name);
539
 
    if (library == NULL)
 
715
    if (p == buffer + sizeof(buffer) - 1)
540
716
    {
541
 
      errmsg_printf(ERRMSG_LVL_ERROR,
542
 
                    _("Couldn't load plugin library named '%s'.\n"),
543
 
                    plugin_name.c_str());
544
 
      return true;
 
717
      errmsg_printf(ERRMSG_LVL_ERROR, _("plugin-load parameter too long"));
 
718
      return(true);
545
719
    }
546
720
 
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
 
 
 
721
    switch ((*(p++)= *(list++))) {
 
722
    case '\0':
 
723
      list= NULL; /* terminate the loop */
 
724
      /* fall through */
 
725
    case ':':     /* can't use this as delimiter as it may be drive letter */
 
726
    case ',':
 
727
      str->str[str->length]= '\0';
 
728
      if (str == &name)  // load all plugins in named module
 
729
      {
 
730
        if (!name.length)
 
731
        {
 
732
          p--;    /* reset pointer */
 
733
          continue;
 
734
        }
 
735
 
 
736
        dl= name;
 
737
        if ((plugin_dl= plugin_dl_add(&dl)))
 
738
        {
 
739
          for (plugin= plugin_dl->plugins; plugin->name; plugin++)
 
740
          {
 
741
            name.str= (char *) plugin->name;
 
742
            name.length= strlen(name.str);
 
743
 
 
744
            free_root(tmp_root, MYF(MY_MARK_BLOCKS_FREE));
 
745
            if (plugin_add(plugins, tmp_root, &name, &dl, argc, argv))
 
746
              goto error;
 
747
          }
 
748
          plugin_dl_del(&dl); // reduce ref count
 
749
        }
 
750
      }
 
751
      else
 
752
      {
 
753
        free_root(tmp_root, MYF(MY_MARK_BLOCKS_FREE));
 
754
        if (plugin_add(plugins, tmp_root, &name, &dl, argc, argv))
 
755
          goto error;
 
756
      }
 
757
      name.length= dl.length= 0;
 
758
      dl.str= NULL; name.str= p= buffer;
 
759
      str= &name;
 
760
      continue;
 
761
    case '=':
 
762
    case '#':
 
763
      if (str == &name)
 
764
      {
 
765
        name.str[name.length]= '\0';
 
766
        str= &dl;
 
767
        str->str= p;
 
768
        continue;
 
769
      }
 
770
    default:
 
771
      str->length++;
 
772
      continue;
556
773
    }
557
774
  }
558
 
  return false;
 
775
  return(false);
 
776
error:
 
777
  errmsg_printf(ERRMSG_LVL_ERROR, _("Couldn't load plugin named '%s' with soname '%s'."),
 
778
                  name.str, dl.str);
 
779
  return(true);
559
780
}
560
781
 
561
782
 
562
783
void plugin_shutdown(plugin::Registry &registry)
563
784
{
 
785
  uint32_t idx;
 
786
  size_t count= module_array.elements;
 
787
  vector<plugin::Library *> dl;
564
788
 
565
789
  if (initialized)
566
790
  {
578
802
 
579
803
  /* Dispose of the memory */
580
804
 
 
805
  delete_dynamic(&module_array);
 
806
 
 
807
  count= plugin_dl_array.elements;
 
808
  dl.reserve(count);
 
809
  for (idx= 0; idx < count; idx++)
 
810
    dl.push_back(*dynamic_element(&plugin_dl_array, idx,
 
811
                 plugin::Library **));
 
812
  for (idx= 0; idx < count; idx++)
 
813
    free_plugin_mem(dl[idx]);
 
814
  delete_dynamic(&plugin_dl_array);
 
815
 
581
816
  hash_free(&bookmark_hash);
582
817
  free_root(&plugin_mem_root, MYF(0));
583
818
 
592
827
#define DRIZZLE_SYSVAR_NAME(name) name
593
828
#define PLUGIN_VAR_TYPEMASK 0x007f
594
829
 
595
 
static const uint32_t EXTRA_OPTIONS= 1; /* handle the NULL option */
 
830
#define EXTRA_OPTIONS 3 /* options for: 'foo', 'plugin-foo' and NULL */
596
831
 
597
832
typedef DECLARE_DRIZZLE_SYSVAR_BASIC(sysvar_bool_t, bool);
598
833
typedef DECLARE_DRIZZLE_SessionVAR_BASIC(sessionvar_bool_t, bool);
599
834
typedef DECLARE_DRIZZLE_SYSVAR_BASIC(sysvar_str_t, char *);
600
835
typedef DECLARE_DRIZZLE_SessionVAR_BASIC(sessionvar_str_t, char *);
601
836
 
 
837
typedef DECLARE_DRIZZLE_SYSVAR_TYPELIB(sysvar_enum_t, unsigned long);
602
838
typedef DECLARE_DRIZZLE_SessionVAR_TYPELIB(sessionvar_enum_t, unsigned long);
 
839
typedef DECLARE_DRIZZLE_SYSVAR_TYPELIB(sysvar_set_t, uint64_t);
603
840
typedef DECLARE_DRIZZLE_SessionVAR_TYPELIB(sessionvar_set_t, uint64_t);
604
841
 
605
842
typedef DECLARE_DRIZZLE_SYSVAR_SIMPLE(sysvar_int_t, int);
623
860
  default variable data check and update functions
624
861
****************************************************************************/
625
862
 
626
 
static int check_func_bool(Session *, drizzle_sys_var *var,
627
 
                           void *save, drizzle_value *value)
 
863
static int check_func_bool(Session *, struct st_mysql_sys_var *var,
 
864
                           void *save, st_mysql_value *value)
628
865
{
629
866
  char buff[STRING_BUFFER_USUAL_SIZE];
630
867
  const char *strvalue= "NULL", *str;
648
885
      goto err;
649
886
    if (tmp > 1)
650
887
    {
651
 
      internal::llstr(tmp, buff);
 
888
      llstr(tmp, buff);
652
889
      strvalue= buff;
653
890
      goto err;
654
891
    }
662
899
}
663
900
 
664
901
 
665
 
static int check_func_int(Session *session, drizzle_sys_var *var,
666
 
                          void *save, drizzle_value *value)
 
902
static int check_func_int(Session *session, struct st_mysql_sys_var *var,
 
903
                          void *save, st_mysql_value *value)
667
904
{
668
905
  bool fixed;
669
906
  int64_t tmp;
670
 
  struct option options;
 
907
  struct my_option options;
671
908
  value->val_int(value, &tmp);
672
909
  plugin_opt_set_limits(&options, var);
673
910
 
682
919
}
683
920
 
684
921
 
685
 
static int check_func_long(Session *session, drizzle_sys_var *var,
686
 
                          void *save, drizzle_value *value)
 
922
static int check_func_long(Session *session, struct st_mysql_sys_var *var,
 
923
                          void *save, st_mysql_value *value)
687
924
{
688
925
  bool fixed;
689
926
  int64_t tmp;
690
 
  struct option options;
 
927
  struct my_option options;
691
928
  value->val_int(value, &tmp);
692
929
  plugin_opt_set_limits(&options, var);
693
930
 
702
939
}
703
940
 
704
941
 
705
 
static int check_func_int64_t(Session *session, drizzle_sys_var *var,
706
 
                               void *save, drizzle_value *value)
 
942
static int check_func_int64_t(Session *session, struct st_mysql_sys_var *var,
 
943
                               void *save, st_mysql_value *value)
707
944
{
708
945
  bool fixed;
709
946
  int64_t tmp;
710
 
  struct option options;
 
947
  struct my_option options;
711
948
  value->val_int(value, &tmp);
712
949
  plugin_opt_set_limits(&options, var);
713
950
 
721
958
                              var->name, (int64_t) tmp);
722
959
}
723
960
 
724
 
static int check_func_str(Session *session, drizzle_sys_var *,
725
 
                          void *save, drizzle_value *value)
 
961
static int check_func_str(Session *session, struct st_mysql_sys_var *,
 
962
                          void *save, st_mysql_value *value)
726
963
{
727
964
  char buff[STRING_BUFFER_USUAL_SIZE];
728
965
  const char *str;
736
973
}
737
974
 
738
975
 
739
 
static void update_func_bool(Session *, drizzle_sys_var *,
 
976
static int check_func_enum(Session *, struct st_mysql_sys_var *var,
 
977
                           void *save, st_mysql_value *value)
 
978
{
 
979
  char buff[STRING_BUFFER_USUAL_SIZE];
 
980
  const char *strvalue= "NULL", *str;
 
981
  TYPELIB *typelib;
 
982
  int64_t tmp;
 
983
  long result;
 
984
  int length;
 
985
 
 
986
  if (var->flags & PLUGIN_VAR_SessionLOCAL)
 
987
    typelib= ((sessionvar_enum_t*) var)->typelib;
 
988
  else
 
989
    typelib= ((sysvar_enum_t*) var)->typelib;
 
990
 
 
991
  if (value->value_type(value) == DRIZZLE_VALUE_TYPE_STRING)
 
992
  {
 
993
    length= sizeof(buff);
 
994
    if (!(str= value->val_str(value, buff, &length)))
 
995
      goto err;
 
996
    if ((result= (long)find_type(typelib, str, length, 1)-1) < 0)
 
997
    {
 
998
      strvalue= str;
 
999
      goto err;
 
1000
    }
 
1001
  }
 
1002
  else
 
1003
  {
 
1004
    if (value->val_int(value, &tmp))
 
1005
      goto err;
 
1006
    if (tmp >= typelib->count)
 
1007
    {
 
1008
      llstr(tmp, buff);
 
1009
      strvalue= buff;
 
1010
      goto err;
 
1011
    }
 
1012
    result= (long) tmp;
 
1013
  }
 
1014
  *(long*)save= result;
 
1015
  return 0;
 
1016
err:
 
1017
  my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), var->name, strvalue);
 
1018
  return 1;
 
1019
}
 
1020
 
 
1021
 
 
1022
static int check_func_set(Session *, struct st_mysql_sys_var *var,
 
1023
                          void *save, st_mysql_value *value)
 
1024
{
 
1025
  char buff[STRING_BUFFER_USUAL_SIZE], *error= 0;
 
1026
  const char *strvalue= "NULL", *str;
 
1027
  TYPELIB *typelib;
 
1028
  uint64_t result;
 
1029
  uint32_t error_len;
 
1030
  bool not_used;
 
1031
  int length;
 
1032
 
 
1033
  if (var->flags & PLUGIN_VAR_SessionLOCAL)
 
1034
    typelib= ((sessionvar_set_t*) var)->typelib;
 
1035
  else
 
1036
    typelib= ((sysvar_set_t*)var)->typelib;
 
1037
 
 
1038
  if (value->value_type(value) == DRIZZLE_VALUE_TYPE_STRING)
 
1039
  {
 
1040
    length= sizeof(buff);
 
1041
    if (!(str= value->val_str(value, buff, &length)))
 
1042
      goto err;
 
1043
    result= find_set(typelib, str, length, NULL,
 
1044
                     &error, &error_len, &not_used);
 
1045
    if (error_len)
 
1046
    {
 
1047
      length= min((uint32_t)sizeof(buff), error_len);
 
1048
      strncpy(buff, error, length);
 
1049
      buff[length]= '\0';
 
1050
      strvalue= buff;
 
1051
      goto err;
 
1052
    }
 
1053
  }
 
1054
  else
 
1055
  {
 
1056
    if (value->val_int(value, (int64_t *)&result))
 
1057
      goto err;
 
1058
    if (unlikely((result >= (1UL << typelib->count)) &&
 
1059
                 (typelib->count < sizeof(long)*8)))
 
1060
    {
 
1061
      llstr(result, buff);
 
1062
      strvalue= buff;
 
1063
      goto err;
 
1064
    }
 
1065
  }
 
1066
  *(uint64_t*)save= result;
 
1067
  return 0;
 
1068
err:
 
1069
  my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), var->name, strvalue);
 
1070
  return 1;
 
1071
}
 
1072
 
 
1073
 
 
1074
static void update_func_bool(Session *, struct st_mysql_sys_var *,
740
1075
                             void *tgt, const void *save)
741
1076
{
742
1077
  *(bool *) tgt= *(int *) save ? 1 : 0;
743
1078
}
744
1079
 
745
1080
 
746
 
static void update_func_int(Session *, drizzle_sys_var *,
 
1081
static void update_func_int(Session *, struct st_mysql_sys_var *,
747
1082
                             void *tgt, const void *save)
748
1083
{
749
1084
  *(int *)tgt= *(int *) save;
750
1085
}
751
1086
 
752
1087
 
753
 
static void update_func_long(Session *, drizzle_sys_var *,
 
1088
static void update_func_long(Session *, struct st_mysql_sys_var *,
754
1089
                             void *tgt, const void *save)
755
1090
{
756
1091
  *(long *)tgt= *(long *) save;
757
1092
}
758
1093
 
759
1094
 
760
 
static void update_func_int64_t(Session *, drizzle_sys_var *,
 
1095
static void update_func_int64_t(Session *, struct st_mysql_sys_var *,
761
1096
                                 void *tgt, const void *save)
762
1097
{
763
1098
  *(int64_t *)tgt= *(uint64_t *) save;
764
1099
}
765
1100
 
766
1101
 
767
 
static void update_func_str(Session *, drizzle_sys_var *var,
 
1102
static void update_func_str(Session *, struct st_mysql_sys_var *var,
768
1103
                             void *tgt, const void *save)
769
1104
{
770
1105
  char *old= *(char **) tgt;
819
1154
  return(var);
820
1155
}
821
1156
 
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
1157
 
840
1158
/*
841
1159
  called by register_var, construct_options and test_plugin_options.
842
1160
  Returns the 'bookmark' for the named variable.
843
1161
  LOCK_system_variables_hash should be at least read locked
844
1162
*/
845
 
static st_bookmark *find_bookmark(const string &plugin, const char *name, int flags)
 
1163
static st_bookmark *find_bookmark(const char *plugin, const char *name, int flags)
846
1164
{
847
1165
  st_bookmark *result= NULL;
 
1166
  uint32_t namelen, length, pluginlen= 0;
 
1167
  char *varname, *p;
848
1168
 
849
1169
  if (!(flags & PLUGIN_VAR_SessionLOCAL))
850
1170
    return NULL;
851
1171
 
852
 
  const string varname(make_bookmark_name(plugin, name, flags));
853
 
 
 
1172
  namelen= strlen(name);
 
1173
  if (plugin)
 
1174
    pluginlen= strlen(plugin) + 1;
 
1175
  length= namelen + pluginlen + 2;
 
1176
  varname= (char*) malloc(length);
 
1177
 
 
1178
  if (plugin)
 
1179
  {
 
1180
    sprintf(varname+1,"%s_%s",plugin,name);
 
1181
    for (p= varname + 1; *p; p++)
 
1182
      if (*p == '-')
 
1183
        *p= '_';
 
1184
  }
 
1185
  else
 
1186
    memcpy(varname + 1, name, namelen + 1);
 
1187
 
 
1188
  varname[0]= flags & PLUGIN_VAR_TYPEMASK;
854
1189
 
855
1190
  result= (st_bookmark*) hash_search(&bookmark_hash,
856
 
                                     (const unsigned char*) varname.c_str(), varname.size() - 1);
 
1191
                                     (const unsigned char*) varname, length - 1);
857
1192
 
 
1193
  free(varname);
858
1194
  return result;
859
1195
}
860
1196
 
864
1200
  returns null for non session-local variables.
865
1201
  Requires that a write lock is obtained on LOCK_system_variables_hash
866
1202
*/
867
 
static st_bookmark *register_var(const string &plugin, const char *name,
 
1203
static st_bookmark *register_var(const char *plugin, const char *name,
868
1204
                                 int flags)
869
1205
{
870
 
  if (!(flags & PLUGIN_VAR_SessionLOCAL))
871
 
    return NULL;
872
 
 
873
 
  uint32_t size= 0, offset, new_size;
 
1206
  uint32_t length= strlen(plugin) + strlen(name) + 3, size= 0, offset, new_size;
874
1207
  st_bookmark *result;
 
1208
  char *varname, *p;
 
1209
 
 
1210
  if (!(flags & PLUGIN_VAR_SessionLOCAL))
 
1211
    return NULL;
875
1212
 
876
1213
  switch (flags & PLUGIN_VAR_TYPEMASK) {
877
1214
  case PLUGIN_VAR_BOOL:
881
1218
    size= ALIGN_SIZE(sizeof(int));
882
1219
    break;
883
1220
  case PLUGIN_VAR_LONG:
 
1221
  case PLUGIN_VAR_ENUM:
884
1222
    size= ALIGN_SIZE(sizeof(long));
885
1223
    break;
886
1224
  case PLUGIN_VAR_LONGLONG:
 
1225
  case PLUGIN_VAR_SET:
887
1226
    size= ALIGN_SIZE(sizeof(uint64_t));
888
1227
    break;
889
1228
  case PLUGIN_VAR_STR:
894
1233
    return NULL;
895
1234
  };
896
1235
 
 
1236
  varname= ((char*) malloc(length));
 
1237
  sprintf(varname+1, "%s_%s", plugin, name);
 
1238
  for (p= varname + 1; *p; p++)
 
1239
    if (*p == '-')
 
1240
      *p= '_';
897
1241
 
898
 
  if (!(result= find_bookmark(plugin, name, flags)))
 
1242
  if (!(result= find_bookmark(NULL, varname + 1, flags)))
899
1243
  {
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;
 
1244
    result= (st_bookmark*) alloc_root(&plugin_mem_root,
 
1245
                                      sizeof(struct st_bookmark) + length-1);
 
1246
    varname[0]= flags & PLUGIN_VAR_TYPEMASK;
 
1247
    memcpy(result->key, varname, length);
 
1248
    result->name_len= length - 2;
907
1249
    result->offset= -1;
908
1250
 
909
1251
    assert(size && !(size & (size-1))); /* must be power of 2 */
959
1301
      assert(0);
960
1302
    }
961
1303
  }
 
1304
  free(varname);
962
1305
  return result;
963
1306
}
964
1307
 
996
1339
    if (global_lock)
997
1340
      pthread_mutex_lock(&LOCK_global_system_variables);
998
1341
 
999
 
    //safe_mutex_assert_owner(&LOCK_global_system_variables);
 
1342
    safe_mutex_assert_owner(&LOCK_global_system_variables);
1000
1343
 
1001
1344
    memcpy(session->variables.dynamic_variables_ptr +
1002
1345
             session->variables.dynamic_variables_size,
1076
1419
  return (char **)intern_sys_var_ptr(a_session, offset, true);
1077
1420
}
1078
1421
 
 
1422
static uint64_t *mysql_sys_var_ptr_set(Session* a_session, int offset)
 
1423
{
 
1424
  return (uint64_t *)intern_sys_var_ptr(a_session, offset, true);
 
1425
}
 
1426
 
 
1427
static unsigned long *mysql_sys_var_ptr_enum(Session* a_session, int offset)
 
1428
{
 
1429
  return (unsigned long *)intern_sys_var_ptr(a_session, offset, true);
 
1430
}
 
1431
 
 
1432
 
1079
1433
void plugin_sessionvar_init(Session *session)
1080
1434
{
1081
1435
  session->variables.storage_engine= NULL;
1215
1569
    return SHOW_LONGLONG;
1216
1570
  case PLUGIN_VAR_STR:
1217
1571
    return SHOW_CHAR_PTR;
 
1572
  case PLUGIN_VAR_ENUM:
 
1573
  case PLUGIN_VAR_SET:
 
1574
    return SHOW_CHAR;
1218
1575
  default:
1219
1576
    assert(0);
1220
1577
    return SHOW_UNDEF;
1222
1579
}
1223
1580
 
1224
1581
 
1225
 
unsigned char* sys_var_pluginvar::real_value_ptr(Session *session, sql_var_t type)
 
1582
unsigned char* sys_var_pluginvar::real_value_ptr(Session *session, enum_var_type type)
1226
1583
{
1227
1584
  assert(session || (type == OPT_GLOBAL));
1228
1585
  if (plugin_var->flags & PLUGIN_VAR_SessionLOCAL)
1239
1596
TYPELIB* sys_var_pluginvar::plugin_var_typelib(void)
1240
1597
{
1241
1598
  switch (plugin_var->flags & (PLUGIN_VAR_TYPEMASK | PLUGIN_VAR_SessionLOCAL)) {
1242
 
  case PLUGIN_VAR_SessionLOCAL:
 
1599
  case PLUGIN_VAR_ENUM:
 
1600
    return ((sysvar_enum_t *)plugin_var)->typelib;
 
1601
  case PLUGIN_VAR_SET:
 
1602
    return ((sysvar_set_t *)plugin_var)->typelib;
 
1603
  case PLUGIN_VAR_ENUM | PLUGIN_VAR_SessionLOCAL:
1243
1604
    return ((sessionvar_enum_t *)plugin_var)->typelib;
 
1605
  case PLUGIN_VAR_SET | PLUGIN_VAR_SessionLOCAL:
 
1606
    return ((sessionvar_set_t *)plugin_var)->typelib;
1244
1607
  default:
1245
1608
    return NULL;
1246
1609
  }
1248
1611
}
1249
1612
 
1250
1613
 
1251
 
unsigned char* sys_var_pluginvar::value_ptr(Session *session, sql_var_t type, const LEX_STRING *)
 
1614
unsigned char* sys_var_pluginvar::value_ptr(Session *session, enum_var_type type, const LEX_STRING *)
1252
1615
{
1253
1616
  unsigned char* result;
1254
1617
 
1255
1618
  result= real_value_ptr(session, type);
1256
1619
 
 
1620
  if ((plugin_var->flags & PLUGIN_VAR_TYPEMASK) == PLUGIN_VAR_ENUM)
 
1621
    result= (unsigned char*) get_type(plugin_var_typelib(), *(ulong*)result);
 
1622
  else if ((plugin_var->flags & PLUGIN_VAR_TYPEMASK) == PLUGIN_VAR_SET)
 
1623
  {
 
1624
    char buffer[STRING_BUFFER_USUAL_SIZE];
 
1625
    String str(buffer, sizeof(buffer), system_charset_info);
 
1626
    TYPELIB *typelib= plugin_var_typelib();
 
1627
    uint64_t mask= 1, value= *(uint64_t*) result;
 
1628
    uint32_t i;
 
1629
 
 
1630
    str.length(0);
 
1631
    for (i= 0; i < typelib->count; i++, mask<<=1)
 
1632
    {
 
1633
      if (!(value & mask))
 
1634
        continue;
 
1635
      str.append(typelib->type_names[i], typelib->type_lengths[i]);
 
1636
      str.append(',');
 
1637
    }
 
1638
 
 
1639
    result= (unsigned char*) "";
 
1640
    if (str.length())
 
1641
      result= (unsigned char*) session->strmake(str.ptr(), str.length()-1);
 
1642
  }
1257
1643
  return result;
1258
1644
}
1259
1645
 
1274
1660
}
1275
1661
 
1276
1662
 
1277
 
void sys_var_pluginvar::set_default(Session *session, sql_var_t type)
 
1663
void sys_var_pluginvar::set_default(Session *session, enum_var_type type)
1278
1664
{
1279
1665
  const void *src;
1280
1666
  void *tgt;
1303
1689
        case PLUGIN_VAR_LONGLONG:
1304
1690
          src= &((sessionvar_uint64_t_t*) plugin_var)->def_val;
1305
1691
          break;
 
1692
        case PLUGIN_VAR_ENUM:
 
1693
          src= &((sessionvar_enum_t*) plugin_var)->def_val;
 
1694
          break;
 
1695
        case PLUGIN_VAR_SET:
 
1696
          src= &((sessionvar_set_t*) plugin_var)->def_val;
 
1697
          break;
1306
1698
        case PLUGIN_VAR_BOOL:
1307
1699
          src= &((sessionvar_bool_t*) plugin_var)->def_val;
1308
1700
          break;
1370
1762
  options->block_size= (long) (opt)->blk_sz
1371
1763
 
1372
1764
 
1373
 
void plugin_opt_set_limits(struct option *options,
1374
 
                                                                                                         const drizzle_sys_var *opt)
 
1765
static void plugin_opt_set_limits(struct my_option *options,
 
1766
                                  const struct st_mysql_sys_var *opt)
1375
1767
{
1376
1768
  options->sub_size= 0;
1377
1769
 
1396
1788
  case PLUGIN_VAR_LONGLONG | PLUGIN_VAR_UNSIGNED:
1397
1789
    OPTION_SET_LIMITS(GET_ULL, options, (sysvar_uint64_t_t*) opt);
1398
1790
    break;
 
1791
  case PLUGIN_VAR_ENUM:
 
1792
    options->var_type= GET_ENUM;
 
1793
    options->typelib= ((sysvar_enum_t*) opt)->typelib;
 
1794
    options->def_value= ((sysvar_enum_t*) opt)->def_val;
 
1795
    options->min_value= options->block_size= 0;
 
1796
    options->max_value= options->typelib->count - 1;
 
1797
    break;
 
1798
  case PLUGIN_VAR_SET:
 
1799
    options->var_type= GET_SET;
 
1800
    options->typelib= ((sysvar_set_t*) opt)->typelib;
 
1801
    options->def_value= ((sysvar_set_t*) opt)->def_val;
 
1802
    options->min_value= options->block_size= 0;
 
1803
    options->max_value= (1UL << options->typelib->count) - 1;
 
1804
    break;
1399
1805
  case PLUGIN_VAR_BOOL:
1400
1806
    options->var_type= GET_BOOL;
1401
1807
    options->def_value= ((sysvar_bool_t*) opt)->def_val;
1424
1830
  case PLUGIN_VAR_LONGLONG | PLUGIN_VAR_UNSIGNED | PLUGIN_VAR_SessionLOCAL:
1425
1831
    OPTION_SET_LIMITS(GET_ULL, options, (sessionvar_uint64_t_t*) opt);
1426
1832
    break;
 
1833
  case PLUGIN_VAR_ENUM | PLUGIN_VAR_SessionLOCAL:
 
1834
    options->var_type= GET_ENUM;
 
1835
    options->typelib= ((sessionvar_enum_t*) opt)->typelib;
 
1836
    options->def_value= ((sessionvar_enum_t*) opt)->def_val;
 
1837
    options->min_value= options->block_size= 0;
 
1838
    options->max_value= options->typelib->count - 1;
 
1839
    break;
 
1840
  case PLUGIN_VAR_SET | PLUGIN_VAR_SessionLOCAL:
 
1841
    options->var_type= GET_SET;
 
1842
    options->typelib= ((sessionvar_set_t*) opt)->typelib;
 
1843
    options->def_value= ((sessionvar_set_t*) opt)->def_val;
 
1844
    options->min_value= options->block_size= 0;
 
1845
    options->max_value= (1UL << options->typelib->count) - 1;
 
1846
    break;
1427
1847
  case PLUGIN_VAR_BOOL | PLUGIN_VAR_SessionLOCAL:
1428
1848
    options->var_type= GET_BOOL;
1429
1849
    options->def_value= ((sessionvar_bool_t*) opt)->def_val;
1443
1863
    options->arg_type= OPT_ARG;
1444
1864
}
1445
1865
 
1446
 
static int get_one_plugin_option(int, const struct option *, char *)
 
1866
extern "C" bool get_one_plugin_option(int optid, const struct my_option *,
 
1867
                                         char *);
 
1868
 
 
1869
bool get_one_plugin_option(int, const struct my_option *, char *)
1447
1870
{
1448
1871
  return 0;
1449
1872
}
1450
1873
 
1451
1874
 
1452
 
static int construct_options(memory::Root *mem_root, plugin::Module *tmp,
1453
 
                             option *options)
 
1875
static int construct_options(MEM_ROOT *mem_root, plugin::Module *tmp,
 
1876
                             my_option *options, bool can_disable)
1454
1877
{
1455
 
  
1456
 
  int localoptionid= 256;
1457
 
  const string plugin_name(tmp->getManifest().name);
1458
 
 
1459
 
  size_t namelen= plugin_name.size(), optnamelen;
1460
 
 
 
1878
  const char *plugin_name= tmp->getManifest().name;
 
1879
  uint32_t namelen= strlen(plugin_name), optnamelen;
 
1880
  uint32_t buffer_length= namelen * 4 + (can_disable ? 75 : 10);
 
1881
  char *name= (char*) alloc_root(mem_root, buffer_length);
 
1882
  bool *enabled_value= (bool*) alloc_root(mem_root, sizeof(bool));
1461
1883
  char *optname, *p;
1462
1884
  int index= 0, offset= 0;
1463
 
  drizzle_sys_var *opt, **plugin_option;
 
1885
  st_mysql_sys_var *opt, **plugin_option;
1464
1886
  st_bookmark *v;
1465
1887
 
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)
 
1888
  /* support --skip-plugin-foo syntax */
 
1889
  memcpy(name, plugin_name, namelen + 1);
 
1890
  my_casedn_str(&my_charset_utf8_general_ci, name);
 
1891
  sprintf(name+namelen+1, "plugin-%s", name);
 
1892
  /* Now we have namelen + 1 + 7 + namelen + 1 == namelen * 2 + 9. */
 
1893
 
 
1894
  for (p= name + namelen*2 + 8; p > name; p--)
 
1895
    if (*p == '_')
 
1896
      *p= '-';
 
1897
 
 
1898
  if (can_disable)
1470
1899
  {
1471
 
    if (*iter == '_')
1472
 
      *iter= '-';
 
1900
    sprintf(name+namelen*2+10,
 
1901
            "Enable %s plugin. Disable with --skip-%s (will save memory).",
 
1902
            plugin_name, name);
 
1903
    /*
 
1904
      Now we have namelen * 2 + 10 (one char unused) + 7 + namelen + 9 +
 
1905
      20 + namelen + 20 + 1 == namelen * 4 + 67.
 
1906
    */
 
1907
 
 
1908
    options[0].comment= name + namelen*2 + 10;
1473
1909
  }
1474
1910
 
1475
1911
  /*
 
1912
    This whole code around variables and command line parameters is turd
 
1913
    soup.
 
1914
 
 
1915
    e.g. the below assignemnt of having the plugin alaways enabled is never
 
1916
    changed so that './drizzled --skip-innodb --help' shows innodb as enabled.
 
1917
 
 
1918
    But this is just as broken as it was in MySQL and properly fixing everything
 
1919
    is a decent amount of "future work"
 
1920
  */
 
1921
  *enabled_value= true; /* by default, plugin enabled */
 
1922
 
 
1923
  options[1].name= (options[0].name= name) + namelen + 1;
 
1924
  options[0].id= options[1].id= 256; /* must be >255. dup id ok */
 
1925
  options[0].var_type= options[1].var_type= GET_BOOL;
 
1926
  options[0].arg_type= options[1].arg_type= NO_ARG;
 
1927
  options[0].def_value= options[1].def_value= true;
 
1928
  options[0].value= options[0].u_max_value=
 
1929
  options[1].value= options[1].u_max_value= (char**) enabled_value;
 
1930
  options+= 2;
 
1931
 
 
1932
  /*
1476
1933
    Two passes as the 2nd pass will take pointer addresses for use
1477
1934
    by my_getopt and register_var() in the first pass uses realloc
1478
1935
  */
1501
1958
    case PLUGIN_VAR_STR:
1502
1959
      (((sessionvar_str_t *)opt)->resolve)= mysql_sys_var_ptr_str;
1503
1960
      break;
 
1961
    case PLUGIN_VAR_ENUM:
 
1962
      (((sessionvar_enum_t *)opt)->resolve)= mysql_sys_var_ptr_enum;
 
1963
      break;
 
1964
    case PLUGIN_VAR_SET:
 
1965
      (((sessionvar_set_t *)opt)->resolve)= mysql_sys_var_ptr_set;
 
1966
      break;
1504
1967
    default:
1505
1968
      errmsg_printf(ERRMSG_LVL_ERROR, _("Unknown variable type code 0x%x in plugin '%s'."),
1506
 
                      opt->flags, plugin_name.c_str());
 
1969
                      opt->flags, plugin_name);
1507
1970
      return(-1);
1508
1971
    };
1509
1972
  }
1548
2011
          errmsg_printf(ERRMSG_LVL_WARN, _("Server variable %s of plugin %s was forced "
1549
2012
                            "to be read-only: string variable without "
1550
2013
                            "update_func and PLUGIN_VAR_MEMALLOC flag"),
1551
 
                            opt->name, plugin_name.c_str());
 
2014
                            opt->name, plugin_name);
1552
2015
        }
1553
2016
      }
1554
2017
      break;
 
2018
    case PLUGIN_VAR_ENUM:
 
2019
      if (!opt->check)
 
2020
        opt->check= check_func_enum;
 
2021
      if (!opt->update)
 
2022
        opt->update= update_func_long;
 
2023
      break;
 
2024
    case PLUGIN_VAR_SET:
 
2025
      if (!opt->check)
 
2026
        opt->check= check_func_set;
 
2027
      if (!opt->update)
 
2028
        opt->update= update_func_int64_t;
 
2029
      break;
1555
2030
    default:
1556
2031
      errmsg_printf(ERRMSG_LVL_ERROR, _("Unknown variable type code 0x%x in plugin '%s'."),
1557
 
                      opt->flags, plugin_name.c_str());
 
2032
                      opt->flags, plugin_name);
1558
2033
      return(-1);
1559
2034
    }
1560
2035
 
1565
2040
    if (!opt->name)
1566
2041
    {
1567
2042
      errmsg_printf(ERRMSG_LVL_ERROR, _("Missing variable name in plugin '%s'."),
1568
 
                    plugin_name.c_str());
 
2043
                      plugin_name);
1569
2044
      return(-1);
1570
2045
    }
1571
2046
 
1573
2048
    {
1574
2049
      optnamelen= strlen(opt->name);
1575
2050
      optname= (char*) alloc_root(mem_root, namelen + optnamelen + 2);
1576
 
      sprintf(optname, "%s-%s", name.c_str(), opt->name);
 
2051
      sprintf(optname, "%s-%s", name, opt->name);
1577
2052
      optnamelen= namelen + optnamelen + 1;
1578
2053
    }
1579
2054
    else
1582
2057
      if (!(v= find_bookmark(name, opt->name, opt->flags)))
1583
2058
      {
1584
2059
        errmsg_printf(ERRMSG_LVL_ERROR, _("Thread local variable '%s' not allocated "
1585
 
                      "in plugin '%s'."), opt->name, plugin_name.c_str());
 
2060
                        "in plugin '%s'."), opt->name, plugin_name);
1586
2061
        return(-1);
1587
2062
      }
1588
2063
 
1603
2078
    options->name= optname;
1604
2079
    options->comment= opt->comment;
1605
2080
    options->app_type= opt;
1606
 
    options->id= localoptionid++;
 
2081
    options->id= (options-1)->id + 1;
1607
2082
 
1608
2083
    plugin_opt_set_limits(options, opt);
1609
2084
 
1613
2088
    else
1614
2089
      options->value= options->u_max_value= *(char***) (opt + 1);
1615
2090
 
1616
 
    options++;
 
2091
    options[1]= options[0];
 
2092
    options[1].name= p= (char*) alloc_root(mem_root, optnamelen + 8);
 
2093
    options[1].comment= 0; // hidden
 
2094
    sprintf(p,"plugin-%s",optname);
 
2095
 
 
2096
    options+= 2;
1617
2097
  }
1618
2098
 
1619
2099
  return(0);
1620
2100
}
1621
2101
 
1622
2102
 
1623
 
static option *construct_help_options(memory::Root *mem_root, plugin::Module *p)
 
2103
static my_option *construct_help_options(MEM_ROOT *mem_root, plugin::Module *p)
1624
2104
{
1625
 
  drizzle_sys_var **opt;
1626
 
  option *opts;
 
2105
  st_mysql_sys_var **opt;
 
2106
  my_option *opts;
 
2107
  bool can_disable;
1627
2108
  uint32_t count= EXTRA_OPTIONS;
1628
2109
 
1629
 
  for (opt= p->getManifest().system_vars; opt && *opt; opt++, count++) {};
 
2110
  for (opt= p->getManifest().system_vars; opt && *opt; opt++, count+= 2) {};
1630
2111
 
1631
 
  opts= (option*)alloc_root(mem_root, (sizeof(option) * count));
 
2112
  opts= (my_option*)alloc_root(mem_root, (sizeof(my_option) * count));
1632
2113
  if (opts == NULL)
1633
2114
    return NULL;
1634
2115
 
1635
 
  memset(opts, 0, sizeof(option) * count);
1636
 
 
1637
 
  if (construct_options(mem_root, p, opts))
 
2116
  memset(opts, 0, sizeof(my_option) * count);
 
2117
 
 
2118
  if ((my_strcasecmp(&my_charset_utf8_general_ci, p->getName().c_str(), "MyISAM") == 0))
 
2119
    can_disable= false;
 
2120
  else if ((my_strcasecmp(&my_charset_utf8_general_ci, p->getName().c_str(), "MEMORY") == 0))
 
2121
    can_disable= false;
 
2122
  else
 
2123
    can_disable= true;
 
2124
 
 
2125
 
 
2126
  if (construct_options(mem_root, p, opts, can_disable))
1638
2127
    return NULL;
1639
2128
 
1640
2129
  return(opts);
1669
2158
  NOTE:
1670
2159
    Requires that a write-lock is held on LOCK_system_variables_hash
1671
2160
*/
1672
 
static int test_plugin_options(memory::Root *tmp_root, plugin::Module *tmp,
 
2161
static int test_plugin_options(MEM_ROOT *tmp_root, plugin::Module *tmp,
1673
2162
                               int *argc, char **argv)
1674
2163
{
1675
2164
  struct sys_var_chain chain= { NULL, NULL };
1676
 
  drizzle_sys_var **opt;
1677
 
  option *opts= NULL;
 
2165
  bool can_disable;
 
2166
  st_mysql_sys_var **opt;
 
2167
  my_option *opts= NULL;
1678
2168
  int error;
1679
 
  drizzle_sys_var *o;
 
2169
  st_mysql_sys_var *o;
1680
2170
  struct st_bookmark *var;
1681
2171
  uint32_t len, count= EXTRA_OPTIONS;
1682
2172
 
1683
2173
  for (opt= tmp->getManifest().system_vars; opt && *opt; opt++)
1684
 
    count++;
 
2174
    count+= 2; /* --{plugin}-{optname} and --plugin-{plugin}-{optname} */
1685
2175
 
 
2176
  if ((my_strcasecmp(&my_charset_utf8_general_ci, tmp->getName().c_str(), "MyISAM") == 0))
 
2177
    can_disable= false;
 
2178
  else if ((my_strcasecmp(&my_charset_utf8_general_ci, tmp->getName().c_str(), "MEMORY") == 0))
 
2179
    can_disable= false;
 
2180
  else
 
2181
    can_disable= true;
1686
2182
 
1687
2183
  if (count > EXTRA_OPTIONS || (*argc > 1))
1688
2184
  {
1689
 
    if (!(opts= (option*) alloc_root(tmp_root, sizeof(option) * count)))
 
2185
    if (!(opts= (my_option*) alloc_root(tmp_root, sizeof(my_option) * count)))
1690
2186
    {
1691
2187
      errmsg_printf(ERRMSG_LVL_ERROR, _("Out of memory for plugin '%s'."), tmp->getName().c_str());
1692
2188
      return(-1);
1693
2189
    }
1694
 
    memset(opts, 0, sizeof(option) * count);
 
2190
    memset(opts, 0, sizeof(my_option) * count);
1695
2191
 
1696
 
    if (construct_options(tmp_root, tmp, opts))
 
2192
    if (construct_options(tmp_root, tmp, opts, can_disable))
1697
2193
    {
1698
2194
      errmsg_printf(ERRMSG_LVL_ERROR, _("Bad options for plugin '%s'."), tmp->getName().c_str());
1699
2195
      return(-1);
1719
2215
      if (((o= *opt)->flags & PLUGIN_VAR_NOSYSVAR))
1720
2216
        continue;
1721
2217
 
1722
 
      if ((var= find_bookmark(tmp->getName(), o->name, o->flags)))
 
2218
      if ((var= find_bookmark(tmp->getName().c_str(), o->name, o->flags)))
1723
2219
        v= new sys_var_pluginvar(var->key + 1, o);
1724
2220
      else
1725
2221
      {
1776
2272
class OptionCmp
1777
2273
{
1778
2274
public:
1779
 
  bool operator() (const option &a, const option &b)
 
2275
  bool operator() (const my_option &a, const my_option &b)
1780
2276
  {
1781
2277
    return my_strcasecmp(&my_charset_utf8_general_ci, a.name, b.name);
1782
2278
  }
1783
2279
};
1784
2280
 
1785
2281
 
1786
 
void my_print_help_inc_plugins(option *main_options)
 
2282
void my_print_help_inc_plugins(my_option *main_options)
1787
2283
{
1788
 
  plugin::Registry &registry= plugin::Registry::singleton();
1789
 
  vector<option> all_options;
 
2284
  vector<my_option> all_options;
1790
2285
  plugin::Module *p;
1791
 
  memory::Root mem_root;
1792
 
  option *opt= NULL;
 
2286
  MEM_ROOT mem_root;
 
2287
  my_option *opt= NULL;
1793
2288
 
1794
 
  init_alloc_root(&mem_root, 4096);
 
2289
  init_alloc_root(&mem_root, 4096, 4096);
1795
2290
 
1796
2291
  if (initialized)
1797
 
  {
1798
 
    std::map<std::string, plugin::Module *>::const_iterator modules=
1799
 
      registry.getModulesMap().begin();
1800
 
    
1801
 
    while (modules != registry.getModulesMap().end())
 
2292
    for (uint32_t idx= 0; idx < module_array.elements; idx++)
1802
2293
    {
1803
 
      p= (*modules).second;
1804
 
      ++modules;
 
2294
      p= *dynamic_element(&module_array, idx, plugin::Module **);
1805
2295
 
1806
2296
      if (p->getManifest().system_vars == NULL)
1807
2297
        continue;
1820
2310
        }
1821
2311
      }
1822
2312
    }
1823
 
  }
1824
2313
 
1825
2314
  for (;main_options->id; main_options++)
1826
2315
  {
1831
2320
  }
1832
2321
 
1833
2322
  /** 
1834
 
   * @TODO: Fix the option building so that it doens't break sort
 
2323
   * @TODO: Fix the my_option building so that it doens't break sort
1835
2324
   *
1836
2325
   * sort(all_options.begin(), all_options.end(), OptionCmp());
1837
2326
   */
1846
2335
 
1847
2336
}
1848
2337
 
1849
 
} /* namespace drizzled */