← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/module/loader.cc

Merge in Stewart's FK work

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/module/loader.cc
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
 
#include <config.h>
 
16
#include "config.h"
17
17
 
18
18
#include <dlfcn.h>
19
19
 
26
26
 
27
27
#include <boost/program_options.hpp>
28
28
 
29
 
#include <drizzled/option.h>
30
 
#include <drizzled/internal/m_string.h>
31
 
 
32
 
#include <drizzled/plugin.h>
33
 
#include <drizzled/module/load_list.h>
34
 
#include <drizzled/module/library.h>
35
 
#include <drizzled/module/registry.h>
36
 
#include <drizzled/module/option_context.h>
37
 
#include <drizzled/sql_parse.h>
38
 
#include <drizzled/show.h>
39
 
#include <drizzled/cursor.h>
40
 
#include <drizzled/set_var.h>
41
 
#include <drizzled/session.h>
42
 
#include <drizzled/item/null.h>
43
 
#include <drizzled/error.h>
44
 
#include <drizzled/gettext.h>
45
 
#include <drizzled/errmsg_print.h>
46
 
#include <drizzled/strfunc.h>
47
 
#include <drizzled/pthread_globals.h>
48
 
#include <drizzled/util/tokenize.h>
49
 
 
50
 
#include <boost/foreach.hpp>
 
29
#include "drizzled/option.h"
 
30
#include "drizzled/my_hash.h"
 
31
#include "drizzled/internal/m_string.h"
 
32
 
 
33
#include "drizzled/plugin.h"
 
34
#include "drizzled/module/load_list.h"
 
35
#include "drizzled/module/library.h"
 
36
#include "drizzled/module/registry.h"
 
37
#include "drizzled/module/option_context.h"
 
38
#include "drizzled/sql_parse.h"
 
39
#include "drizzled/show.h"
 
40
#include "drizzled/cursor.h"
 
41
#include "drizzled/set_var.h"
 
42
#include "drizzled/session.h"
 
43
#include "drizzled/item/null.h"
 
44
#include "drizzled/error.h"
 
45
#include "drizzled/gettext.h"
 
46
#include "drizzled/errmsg_print.h"
 
47
#include "drizzled/strfunc.h"
 
48
#include "drizzled/pthread_globals.h"
 
49
#include "drizzled/util/tokenize.h"
51
50
 
52
51
/* FreeBSD 2.2.2 does not define RTLD_NOW) */
53
52
#ifndef RTLD_NOW
61
60
/** These exist just to prevent symbols from being optimized out */
62
61
typedef drizzled::module::Manifest drizzled_builtin_list[];
63
62
extern drizzled_builtin_list PANDORA_BUILTIN_SYMBOLS_LIST;
64
 
extern drizzled_builtin_list PANDORA_BUILTIN_LOAD_SYMBOLS_LIST;
65
63
drizzled::module::Manifest *drizzled_builtins[]=
66
64
{
67
65
  PANDORA_BUILTIN_SYMBOLS_LIST, NULL
68
66
};
69
 
drizzled::module::Manifest *drizzled_load_builtins[]=
70
 
{
71
 
  PANDORA_BUILTIN_LOAD_SYMBOLS_LIST, NULL
72
 
};
73
67
 
74
68
namespace drizzled
75
69
{
76
70
 
77
71
 
78
 
typedef vector<string> PluginOptions;
79
 
static PluginOptions opt_plugin_load;
80
 
static PluginOptions opt_plugin_add;
81
 
static PluginOptions opt_plugin_remove;
 
72
class sys_var_pluginvar;
 
73
static vector<sys_var_pluginvar *> plugin_sysvar_vec;
 
74
 
 
75
char *opt_plugin_add= NULL;
 
76
char *opt_plugin_remove= NULL;
 
77
char *opt_plugin_load= NULL;
 
78
char *opt_plugin_dir_ptr;
 
79
char opt_plugin_dir[FN_REFLEN];
 
80
const char *opt_plugin_load_default= PANDORA_PLUGIN_LIST;
82
81
const char *builtin_plugins= PANDORA_BUILTIN_LIST;
83
 
const char *builtin_load_plugins= PANDORA_BUILTIN_LOAD_LIST;
84
82
 
85
83
/* Note that 'int version' must be the first field of every plugin
86
84
   sub-structure (plugin->info).
97
95
*/
98
96
static memory::Root plugin_mem_root(4096);
99
97
static uint32_t global_variables_dynamic_size= 0;
 
98
static HASH bookmark_hash;
100
99
 
101
100
 
102
101
/*
108
107
  Item *item;
109
108
};
110
109
 
111
 
class Bookmark
 
110
 
 
111
/*
 
112
  stored in bookmark_hash, this structure is never removed from the
 
113
  hash and is used to mark a single offset for a session local variable
 
114
  even if plugins have been uninstalled and reinstalled, repeatedly.
 
115
  This structure is allocated from plugin_mem_root.
 
116
 
 
117
  The key format is as follows:
 
118
    1 byte         - variable type code
 
119
    name_len bytes - variable name
 
120
    '\0'           - end of key
 
121
*/
 
122
struct st_bookmark
112
123
{
113
 
public:
114
 
  Bookmark() :
115
 
    type_code(0),
116
 
    offset(0),
117
 
    version(0),
118
 
    key("")
119
 
  {}
120
 
  uint8_t type_code;
 
124
  uint32_t name_len;
121
125
  int offset;
122
126
  uint32_t version;
123
 
  string key;
124
 
};
125
 
 
126
 
typedef boost::unordered_map<string, Bookmark> bookmark_unordered_map;
127
 
static bookmark_unordered_map bookmark_hash;
128
 
 
 
127
  char key[1];
 
128
};
 
129
 
 
130
 
 
131
/*
 
132
  sys_var class for access to all plugin variables visible to the user
 
133
*/
 
134
class sys_var_pluginvar: public sys_var
 
135
{
 
136
public:
 
137
  module::Module *plugin;
 
138
  drizzle_sys_var *plugin_var;
 
139
 
 
140
  sys_var_pluginvar(const std::string name_arg,
 
141
                    drizzle_sys_var *plugin_var_arg)
 
142
    :sys_var(name_arg), plugin_var(plugin_var_arg) {}
 
143
  sys_var_pluginvar *cast_pluginvar() { return this; }
 
144
  bool is_readonly() const { return plugin_var->flags & PLUGIN_VAR_READONLY; }
 
145
  bool check_type(sql_var_t type)
 
146
  { return !(plugin_var->flags & PLUGIN_VAR_SessionLOCAL) && type != OPT_GLOBAL; }
 
147
  bool check_update_type(Item_result type);
 
148
  SHOW_TYPE show_type();
 
149
  unsigned char* real_value_ptr(Session *session, sql_var_t type);
 
150
  TYPELIB* plugin_var_typelib(void);
 
151
  unsigned char* value_ptr(Session *session, sql_var_t type,
 
152
                           const LEX_STRING *base);
 
153
  bool check(Session *session, set_var *var);
 
154
  bool check_default(sql_var_t)
 
155
    { return is_readonly(); }
 
156
  void set_default(Session *session, sql_var_t);
 
157
  bool update(Session *session, set_var *var);
 
158
};
129
159
 
130
160
 
131
161
/* prototypes */
132
162
static void plugin_prune_list(vector<string> &plugin_list,
133
163
                              const vector<string> &plugins_to_remove);
134
164
static bool plugin_load_list(module::Registry &registry,
135
 
                             memory::Root *tmp_root,
 
165
                             memory::Root *tmp_root, int *argc, char **argv,
136
166
                             const set<string> &plugin_list,
137
167
                             po::options_description &long_options,
138
168
                             bool builtin= false);
139
169
static int test_plugin_options(memory::Root *, module::Module *,
 
170
                               int *, char **,
140
171
                               po::options_description &long_options);
141
 
static void unlock_variables(Session *session, drizzle_system_variables *vars);
142
 
static void cleanup_variables(drizzle_system_variables *vars);
 
172
static void unlock_variables(Session *session, struct system_variables *vars);
 
173
static void cleanup_variables(Session *session, struct system_variables *vars);
 
174
static void plugin_vars_free_values(sys_var *vars);
 
175
 
 
176
/* declared in set_var.cc */
 
177
extern sys_var *intern_find_sys_var(const char *str, uint32_t length, bool no_error);
 
178
extern bool throw_bounds_warning(Session *session, bool fixed, bool unsignd,
 
179
                                 const std::string &name, int64_t val);
 
180
 
 
181
static bool throw_bounds_warning(Session *session, bool fixed, bool unsignd,
 
182
                                 const char *name, int64_t val)
 
183
{
 
184
  const std::string name_str(name);
 
185
  return throw_bounds_warning(session, fixed, unsignd, name_str, val);
 
186
}
 
187
 
 
188
/****************************************************************************
 
189
  Value type thunks, allows the C world to play in the C++ world
 
190
****************************************************************************/
 
191
 
 
192
static int item_value_type(drizzle_value *value)
 
193
{
 
194
  switch (((st_item_value_holder*)value)->item->result_type()) {
 
195
  case INT_RESULT:
 
196
    return DRIZZLE_VALUE_TYPE_INT;
 
197
  case REAL_RESULT:
 
198
    return DRIZZLE_VALUE_TYPE_REAL;
 
199
  default:
 
200
    return DRIZZLE_VALUE_TYPE_STRING;
 
201
  }
 
202
}
 
203
 
 
204
static const char *item_val_str(drizzle_value *value,
 
205
                                char *buffer, int *length)
 
206
{
 
207
  String str(buffer, *length, system_charset_info), *res;
 
208
  if (!(res= ((st_item_value_holder*)value)->item->val_str(&str)))
 
209
    return NULL;
 
210
  *length= res->length();
 
211
  if (res->c_ptr_quick() == buffer)
 
212
    return buffer;
 
213
 
 
214
  /*
 
215
    Lets be nice and create a temporary string since the
 
216
    buffer was too small
 
217
  */
 
218
  return current_session->strmake(res->c_ptr_quick(), res->length());
 
219
}
 
220
 
 
221
 
 
222
static int item_val_int(drizzle_value *value, int64_t *buf)
 
223
{
 
224
  Item *item= ((st_item_value_holder*)value)->item;
 
225
  *buf= item->val_int();
 
226
  if (item->is_null())
 
227
    return 1;
 
228
  return 0;
 
229
}
 
230
 
 
231
 
 
232
static int item_val_real(drizzle_value *value, double *buf)
 
233
{
 
234
  Item *item= ((st_item_value_holder*)value)->item;
 
235
  *buf= item->val_real();
 
236
  if (item->is_null())
 
237
    return 1;
 
238
  return 0;
 
239
}
143
240
 
144
241
 
145
242
/****************************************************************************
155
252
*/
156
253
static bool plugin_add(module::Registry &registry, memory::Root *tmp_root,
157
254
                       module::Library *library,
 
255
                       int *argc, char **argv,
158
256
                       po::options_description &long_options)
159
257
{
160
258
  if (! initialized)
162
260
 
163
261
  if (registry.find(library->getName()))
164
262
  {
165
 
    errmsg_printf(error::WARN, ER(ER_PLUGIN_EXISTS),
 
263
    errmsg_printf(ERRMSG_LVL_WARN, ER(ER_PLUGIN_EXISTS),
166
264
                  library->getName().c_str());
167
265
    return false;
168
266
  }
173
271
 
174
272
  if (registry.find(manifest->name))
175
273
  {
176
 
    errmsg_printf(error::ERROR, 
 
274
    errmsg_printf(ERRMSG_LVL_ERROR, 
177
275
                  _("Plugin '%s' contains the name '%s' in its manifest, which "
178
276
                    "has already been registered.\n"),
179
277
                  library->getName().c_str(),
185
283
  if (tmp == NULL)
186
284
    return true;
187
285
 
188
 
  if (!test_plugin_options(tmp_root, tmp, long_options))
 
286
  if (!test_plugin_options(tmp_root, tmp, argc, argv, long_options))
189
287
  {
190
288
    registry.add(tmp);
191
289
    return false;
192
290
  }
193
 
  errmsg_printf(error::ERROR, ER(ER_CANT_FIND_DL_ENTRY),
 
291
  errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_CANT_FIND_DL_ENTRY),
194
292
                library->getName().c_str());
195
293
  return true;
196
294
}
197
295
 
198
296
 
 
297
static void delete_module(module::Module *module)
 
298
{
 
299
  /* Free allocated strings before deleting the plugin. */
 
300
  plugin_vars_free_values(module->system_vars);
 
301
  module->isInited= false;
 
302
  mysql_del_sys_var_chain(module->system_vars);
 
303
  delete module;
 
304
}
 
305
 
 
306
 
199
307
static void reap_plugins(module::Registry &registry)
200
308
{
201
309
  std::map<std::string, module::Module *>::const_iterator modules=
204
312
  while (modules != registry.getModulesMap().end())
205
313
  {
206
314
    module::Module *module= (*modules).second;
207
 
    delete module;
 
315
    delete_module(module);
208
316
    ++modules;
209
317
  }
 
318
 
 
319
  drizzle_del_plugin_sysvar();
 
320
}
 
321
 
 
322
 
 
323
static void plugin_initialize_vars(module::Module *module)
 
324
{
 
325
  /*
 
326
    set the plugin attribute of plugin's sys vars so they are pointing
 
327
    to the active plugin
 
328
  */
 
329
  if (module->system_vars)
 
330
  {
 
331
    sys_var_pluginvar *var= module->system_vars->cast_pluginvar();
 
332
    for (;;)
 
333
    {
 
334
      var->plugin= module;
 
335
      if (! var->getNext())
 
336
        break;
 
337
      var= var->getNext()->cast_pluginvar();
 
338
    }
 
339
  }
210
340
}
211
341
 
212
342
 
220
350
  {
221
351
    if (module->getManifest().init(loading_context))
222
352
    {
223
 
      errmsg_printf(error::ERROR,
 
353
      errmsg_printf(ERRMSG_LVL_ERROR,
224
354
                    _("Plugin '%s' init function returned error.\n"),
225
355
                    module->getName().c_str());
226
356
      return true;
233
363
}
234
364
 
235
365
 
236
 
inline static void dashes_to_underscores(std::string &name_in,
237
 
                                         char from= '-', char to= '_')
238
 
{
239
 
  for (string::iterator p= name_in.begin();
240
 
       p != name_in.end();
241
 
       ++p)
242
 
  {
243
 
    if (*p == from)
244
 
    {
245
 
      *p= to;
246
 
    }
247
 
  }
248
 
}
249
 
 
250
 
inline static void underscores_to_dashes(std::string &name_in)
251
 
{
252
 
  return dashes_to_underscores(name_in, '_', '-');
253
 
}
254
 
 
255
 
static void compose_plugin_options(vector<string> &target,
256
 
                                   vector<string> options)
257
 
{
258
 
  for (vector<string>::iterator it= options.begin();
259
 
       it != options.end();
260
 
       ++it)
261
 
  {
262
 
    tokenize(*it, target, ",", true);
263
 
  }
264
 
  for (vector<string>::iterator it= target.begin();
265
 
       it != target.end();
266
 
       ++it)
267
 
  {
268
 
    dashes_to_underscores(*it);
269
 
  }
270
 
}
271
 
 
272
 
void compose_plugin_add(vector<string> options)
273
 
{
274
 
  compose_plugin_options(opt_plugin_add, options);
275
 
}
276
 
 
277
 
void compose_plugin_remove(vector<string> options)
278
 
{
279
 
  compose_plugin_options(opt_plugin_remove, options);
280
 
}
281
 
 
282
 
void notify_plugin_load(string in_plugin_load)
283
 
{
284
 
  tokenize(in_plugin_load, opt_plugin_load, ",", true);
285
 
}
 
366
static unsigned char *get_bookmark_hash_key(const unsigned char *buff,
 
367
                                            size_t *length, bool)
 
368
{
 
369
  struct st_bookmark *var= (st_bookmark *)buff;
 
370
  *length= var->name_len + 1;
 
371
  return (unsigned char*) var->key;
 
372
}
 
373
 
286
374
 
287
375
/*
288
376
  The logic is that we first load and initialize all compiled in plugins.
292
380
  Finally we initialize everything, aka the dynamic that have yet to initialize.
293
381
*/
294
382
bool plugin_init(module::Registry &registry,
 
383
                 int *argc, char **argv,
295
384
                 po::options_description &long_options)
296
385
{
297
386
  memory::Root tmp_root(4096);
299
388
  if (initialized)
300
389
    return false;
301
390
 
 
391
  if (hash_init(&bookmark_hash, &my_charset_bin, 16, 0, 0,
 
392
                  get_bookmark_hash_key, NULL, HASH_UNIQUE))
 
393
  {
 
394
    tmp_root.free_root(MYF(0));
 
395
    return true;
 
396
  }
 
397
 
 
398
 
302
399
  initialized= 1;
303
400
 
304
 
  PluginOptions builtin_load_list;
305
 
  tokenize(builtin_load_plugins, builtin_load_list, ",", true);
306
 
 
307
 
  PluginOptions builtin_list;
 
401
  vector<string> builtin_list;
308
402
  tokenize(builtin_plugins, builtin_list, ",", true);
309
403
 
310
404
  bool load_failed= false;
311
 
 
312
 
  if (opt_plugin_add.size() > 0)
313
 
  {
314
 
    for (PluginOptions::iterator iter= opt_plugin_add.begin();
315
 
         iter != opt_plugin_add.end();
316
 
         ++iter)
317
 
    {
318
 
      if (find(builtin_list.begin(),
319
 
               builtin_list.end(), *iter) != builtin_list.end())
320
 
      {
321
 
        builtin_load_list.push_back(*iter);
322
 
      }
323
 
      else
324
 
      {
325
 
        opt_plugin_load.push_back(*iter);
326
 
      }
327
 
    }
328
 
  }
329
 
 
330
 
  if (opt_plugin_remove.size() > 0)
331
 
  {
332
 
    plugin_prune_list(opt_plugin_load, opt_plugin_remove);
333
 
    plugin_prune_list(builtin_load_list, opt_plugin_remove);
 
405
  vector<string> plugin_list;
 
406
  if (opt_plugin_load)
 
407
  {
 
408
    tokenize(opt_plugin_load, plugin_list, ",", true);
 
409
  }
 
410
  else
 
411
  {
 
412
    tokenize(opt_plugin_load_default, plugin_list, ",", true);
 
413
  }
 
414
  if (opt_plugin_add)
 
415
  {
 
416
    tokenize(opt_plugin_add, plugin_list, ",", true);
 
417
  }
 
418
 
 
419
  if (opt_plugin_remove)
 
420
  {
 
421
    vector<string> plugins_to_remove;
 
422
    tokenize(opt_plugin_remove, plugins_to_remove, ",", true);
 
423
    plugin_prune_list(plugin_list, plugins_to_remove);
 
424
    plugin_prune_list(builtin_list, plugins_to_remove);
334
425
  }
335
426
 
336
427
 
337
428
  /*
338
429
    First we register builtin plugins
339
430
  */
340
 
  const set<string> builtin_list_set(builtin_load_list.begin(),
341
 
                                     builtin_load_list.end());
342
 
  load_failed= plugin_load_list(registry, &tmp_root,
 
431
  const set<string> builtin_list_set(builtin_list.begin(), builtin_list.end());
 
432
  load_failed= plugin_load_list(registry, &tmp_root, argc, argv,
343
433
                                builtin_list_set, long_options, true);
344
434
  if (load_failed)
345
435
  {
348
438
  }
349
439
 
350
440
  /* Uniquify the list */
351
 
  const set<string> plugin_list_set(opt_plugin_load.begin(),
352
 
                                    opt_plugin_load.end());
 
441
  const set<string> plugin_list_set(plugin_list.begin(), plugin_list.end());
353
442
  
354
443
  /* Register all dynamic plugins */
355
 
  load_failed= plugin_load_list(registry, &tmp_root,
 
444
  load_failed= plugin_load_list(registry, &tmp_root, argc, argv,
356
445
                                plugin_list_set, long_options);
357
446
  if (load_failed)
358
447
  {
365
454
  return false;
366
455
}
367
456
 
368
 
bool plugin_finalize(module::Registry &registry)
 
457
void plugin_finalize(module::Registry &registry)
369
458
{
 
459
 
370
460
  /*
371
461
    Now we initialize all remaining plugins
372
462
  */
373
 
  module::Registry::ModuleList module_list= registry.getList();
374
 
  module::Registry::ModuleList::iterator modules= module_list.begin();
 
463
  std::map<std::string, module::Module *>::const_iterator modules=
 
464
    registry.getModulesMap().begin();
375
465
    
376
 
  while (modules != module_list.end())
 
466
  while (modules != registry.getModulesMap().end())
377
467
  {
378
 
    module::Module *module= *modules;
 
468
    module::Module *module= (*modules).second;
379
469
    ++modules;
380
470
    if (module->isInited == false)
381
471
    {
 
472
      plugin_initialize_vars(module);
 
473
 
382
474
      if (plugin_initialize(registry, module))
383
 
      {
384
 
        registry.remove(module);
385
 
        delete module;
386
 
        return true;
387
 
      }
 
475
        delete_module(module);
388
476
    }
389
477
  }
390
 
 
391
 
 
392
 
  BOOST_FOREACH(plugin::Plugin::map::value_type value, registry.getPluginsMap())
393
 
  {
394
 
    value.second->prime();
395
 
  }
396
 
 
397
 
  return false;
398
 
}
399
 
 
400
 
/*
401
 
  Window of opportunity for plugins to issue any queries with the database up and running but with no user's connected.
402
 
*/
403
 
void plugin_startup_window(module::Registry &registry, drizzled::Session &session)
404
 
{
405
 
  BOOST_FOREACH(plugin::Plugin::map::value_type value, registry.getPluginsMap())
406
 
  {
407
 
    value.second->startup(session);
408
 
  }
409
478
}
410
479
 
411
480
class PrunePlugin :
443
512
  called only by plugin_init()
444
513
*/
445
514
static bool plugin_load_list(module::Registry &registry,
446
 
                             memory::Root *tmp_root,
 
515
                             memory::Root *tmp_root, int *argc, char **argv,
447
516
                             const set<string> &plugin_list,
448
517
                             po::options_description &long_options,
449
518
                             bool builtin)
459
528
    library= registry.addLibrary(plugin_name, builtin);
460
529
    if (library == NULL)
461
530
    {
462
 
      errmsg_printf(error::ERROR,
 
531
      errmsg_printf(ERRMSG_LVL_ERROR,
463
532
                    _("Couldn't load plugin library named '%s'.\n"),
464
533
                    plugin_name.c_str());
465
534
      return true;
466
535
    }
467
536
 
468
537
    tmp_root->free_root(MYF(memory::MARK_BLOCKS_FREE));
469
 
    if (plugin_add(registry, tmp_root, library, long_options))
 
538
    if (plugin_add(registry, tmp_root, library, argc, argv, long_options))
470
539
    {
471
540
      registry.removeLibrary(plugin_name);
472
 
      errmsg_printf(error::ERROR,
 
541
      errmsg_printf(ERRMSG_LVL_ERROR,
473
542
                    _("Couldn't load plugin named '%s'.\n"),
474
543
                    plugin_name.c_str());
475
544
      return true;
491
560
    unlock_variables(NULL, &global_system_variables);
492
561
    unlock_variables(NULL, &max_system_variables);
493
562
 
494
 
    cleanup_variables(&global_system_variables);
495
 
    cleanup_variables(&max_system_variables);
 
563
    cleanup_variables(NULL, &global_system_variables);
 
564
    cleanup_variables(NULL, &max_system_variables);
496
565
 
497
566
    initialized= 0;
498
567
  }
499
568
 
500
569
  /* Dispose of the memory */
 
570
 
 
571
  hash_free(&bookmark_hash);
501
572
  plugin_mem_root.free_root(MYF(0));
502
573
 
503
574
  global_variables_dynamic_size= 0;
504
575
}
505
576
 
 
577
/****************************************************************************
 
578
  Internal type declarations for variables support
 
579
****************************************************************************/
 
580
 
 
581
#undef DRIZZLE_SYSVAR_NAME
 
582
#define DRIZZLE_SYSVAR_NAME(name) name
 
583
#define PLUGIN_VAR_TYPEMASK 0x007f
 
584
 
 
585
static const uint32_t EXTRA_OPTIONS= 1; /* handle the NULL option */
 
586
 
 
587
typedef DECLARE_DRIZZLE_SYSVAR_BASIC(sysvar_bool_t, bool);
 
588
typedef DECLARE_DRIZZLE_SessionVAR_BASIC(sessionvar_bool_t, bool);
 
589
typedef DECLARE_DRIZZLE_SYSVAR_BASIC(sysvar_str_t, char *);
 
590
typedef DECLARE_DRIZZLE_SessionVAR_BASIC(sessionvar_str_t, char *);
 
591
 
 
592
typedef DECLARE_DRIZZLE_SessionVAR_TYPELIB(sessionvar_enum_t, unsigned long);
 
593
typedef DECLARE_DRIZZLE_SessionVAR_TYPELIB(sessionvar_set_t, uint64_t);
 
594
 
 
595
typedef DECLARE_DRIZZLE_SYSVAR_SIMPLE(sysvar_int_t, int);
 
596
typedef DECLARE_DRIZZLE_SYSVAR_SIMPLE(sysvar_long_t, long);
 
597
typedef DECLARE_DRIZZLE_SYSVAR_SIMPLE(sysvar_int64_t_t, int64_t);
 
598
typedef DECLARE_DRIZZLE_SYSVAR_SIMPLE(sysvar_uint_t, uint);
 
599
typedef DECLARE_DRIZZLE_SYSVAR_SIMPLE(sysvar_ulong_t, ulong);
 
600
typedef DECLARE_DRIZZLE_SYSVAR_SIMPLE(sysvar_uint64_t_t, uint64_t);
 
601
 
 
602
typedef DECLARE_DRIZZLE_SessionVAR_SIMPLE(sessionvar_int_t, int);
 
603
typedef DECLARE_DRIZZLE_SessionVAR_SIMPLE(sessionvar_long_t, long);
 
604
typedef DECLARE_DRIZZLE_SessionVAR_SIMPLE(sessionvar_int64_t_t, int64_t);
 
605
typedef DECLARE_DRIZZLE_SessionVAR_SIMPLE(sessionvar_uint_t, uint);
 
606
typedef DECLARE_DRIZZLE_SessionVAR_SIMPLE(sessionvar_ulong_t, ulong);
 
607
typedef DECLARE_DRIZZLE_SessionVAR_SIMPLE(sessionvar_uint64_t_t, uint64_t);
 
608
 
 
609
typedef bool *(*mysql_sys_var_ptr_p)(Session* a_session, int offset);
 
610
 
 
611
 
 
612
/****************************************************************************
 
613
  default variable data check and update functions
 
614
****************************************************************************/
 
615
 
 
616
static int check_func_bool(Session *, drizzle_sys_var *var,
 
617
                           void *save, drizzle_value *value)
 
618
{
 
619
  char buff[STRING_BUFFER_USUAL_SIZE];
 
620
  const char *strvalue= "NULL", *str;
 
621
  int result, length;
 
622
  int64_t tmp;
 
623
 
 
624
  if (value->value_type(value) == DRIZZLE_VALUE_TYPE_STRING)
 
625
  {
 
626
    length= sizeof(buff);
 
627
    if (!(str= value->val_str(value, buff, &length)) ||
 
628
        (result= find_type(&bool_typelib, str, length, 1)-1) < 0)
 
629
    {
 
630
      if (str)
 
631
        strvalue= str;
 
632
      goto err;
 
633
    }
 
634
  }
 
635
  else
 
636
  {
 
637
    if (value->val_int(value, &tmp) < 0)
 
638
      goto err;
 
639
    if (tmp > 1)
 
640
    {
 
641
      internal::llstr(tmp, buff);
 
642
      strvalue= buff;
 
643
      goto err;
 
644
    }
 
645
    result= (int) tmp;
 
646
  }
 
647
  *(int*)save= -result;
 
648
  return 0;
 
649
err:
 
650
  my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), var->name, strvalue);
 
651
  return 1;
 
652
}
 
653
 
 
654
 
 
655
static int check_func_int(Session *session, drizzle_sys_var *var,
 
656
                          void *save, drizzle_value *value)
 
657
{
 
658
  bool fixed;
 
659
  int64_t tmp;
 
660
  struct option options;
 
661
  value->val_int(value, &tmp);
 
662
  plugin_opt_set_limits(&options, var);
 
663
 
 
664
  if (var->flags & PLUGIN_VAR_UNSIGNED)
 
665
    *(uint32_t *)save= (uint32_t) getopt_ull_limit_value((uint64_t) tmp, &options,
 
666
                                                   &fixed);
 
667
  else
 
668
    *(int *)save= (int) getopt_ll_limit_value(tmp, &options, &fixed);
 
669
 
 
670
  return throw_bounds_warning(session, fixed, var->flags & PLUGIN_VAR_UNSIGNED,
 
671
                              var->name, (int64_t) tmp);
 
672
}
 
673
 
 
674
 
 
675
static int check_func_long(Session *session, drizzle_sys_var *var,
 
676
                          void *save, drizzle_value *value)
 
677
{
 
678
  bool fixed;
 
679
  int64_t tmp;
 
680
  struct option options;
 
681
  value->val_int(value, &tmp);
 
682
  plugin_opt_set_limits(&options, var);
 
683
 
 
684
  if (var->flags & PLUGIN_VAR_UNSIGNED)
 
685
    *(ulong *)save= (ulong) getopt_ull_limit_value((uint64_t) tmp, &options,
 
686
                                                   &fixed);
 
687
  else
 
688
    *(long *)save= (long) getopt_ll_limit_value(tmp, &options, &fixed);
 
689
 
 
690
  return throw_bounds_warning(session, fixed, var->flags & PLUGIN_VAR_UNSIGNED,
 
691
                              var->name, (int64_t) tmp);
 
692
}
 
693
 
 
694
 
 
695
static int check_func_int64_t(Session *session, drizzle_sys_var *var,
 
696
                               void *save, drizzle_value *value)
 
697
{
 
698
  bool fixed;
 
699
  int64_t tmp;
 
700
  struct option options;
 
701
  value->val_int(value, &tmp);
 
702
  plugin_opt_set_limits(&options, var);
 
703
 
 
704
  if (var->flags & PLUGIN_VAR_UNSIGNED)
 
705
    *(uint64_t *)save= getopt_ull_limit_value((uint64_t) tmp, &options,
 
706
                                               &fixed);
 
707
  else
 
708
    *(int64_t *)save= getopt_ll_limit_value(tmp, &options, &fixed);
 
709
 
 
710
  return throw_bounds_warning(session, fixed, var->flags & PLUGIN_VAR_UNSIGNED,
 
711
                              var->name, (int64_t) tmp);
 
712
}
 
713
 
 
714
static int check_func_str(Session *session, drizzle_sys_var *,
 
715
                          void *save, drizzle_value *value)
 
716
{
 
717
  char buff[STRING_BUFFER_USUAL_SIZE];
 
718
  const char *str;
 
719
  int length;
 
720
 
 
721
  length= sizeof(buff);
 
722
  if ((str= value->val_str(value, buff, &length)))
 
723
    str= session->strmake(str, length);
 
724
  *(const char**)save= str;
 
725
  return 0;
 
726
}
 
727
 
 
728
 
 
729
static void update_func_bool(Session *, drizzle_sys_var *,
 
730
                             void *tgt, const void *save)
 
731
{
 
732
  *(bool *) tgt= *(int *) save ? 1 : 0;
 
733
}
 
734
 
 
735
 
 
736
static void update_func_int(Session *, drizzle_sys_var *,
 
737
                             void *tgt, const void *save)
 
738
{
 
739
  *(int *)tgt= *(int *) save;
 
740
}
 
741
 
 
742
 
 
743
static void update_func_long(Session *, drizzle_sys_var *,
 
744
                             void *tgt, const void *save)
 
745
{
 
746
  *(long *)tgt= *(long *) save;
 
747
}
 
748
 
 
749
 
 
750
static void update_func_int64_t(Session *, drizzle_sys_var *,
 
751
                                 void *tgt, const void *save)
 
752
{
 
753
  *(int64_t *)tgt= *(uint64_t *) save;
 
754
}
 
755
 
 
756
 
 
757
static void update_func_str(Session *, drizzle_sys_var *var,
 
758
                             void *tgt, const void *save)
 
759
{
 
760
  char *old= *(char **) tgt;
 
761
  *(char **)tgt= *(char **) save;
 
762
  if (var->flags & PLUGIN_VAR_MEMALLOC)
 
763
  {
 
764
    *(char **)tgt= strdup(*(char **) save);
 
765
    free(old);
 
766
    /*
 
767
     * There isn't a _really_ good thing to do here until this whole set_var
 
768
     * mess gets redesigned
 
769
     */
 
770
    if (tgt == NULL)
 
771
      errmsg_printf(ERRMSG_LVL_ERROR, _("Out of memory."));
 
772
 
 
773
  }
 
774
}
 
775
 
506
776
 
507
777
/****************************************************************************
508
778
  System Variables support
509
779
****************************************************************************/
510
780
 
511
781
 
 
782
sys_var *find_sys_var(Session *, const char *str, uint32_t length)
 
783
{
 
784
  sys_var *var;
 
785
  sys_var_pluginvar *pi= NULL;
 
786
  module::Module *module;
 
787
 
 
788
  if ((var= intern_find_sys_var(str, length, false)) &&
 
789
      (pi= var->cast_pluginvar()))
 
790
  {
 
791
    if (!(module= pi->plugin))
 
792
      var= NULL; /* failed to lock it, it must be uninstalling */
 
793
    else if (module->isInited == false)
 
794
    {
 
795
      var= NULL;
 
796
    }
 
797
  }
 
798
 
 
799
  /*
 
800
    If the variable exists but the plugin it is associated with is not ready
 
801
    then the intern_plugin_lock did not raise an error, so we do it here.
 
802
  */
 
803
  if (pi && !var)
 
804
    my_error(ER_UNKNOWN_SYSTEM_VARIABLE, MYF(0), (char*) str);
 
805
  return(var);
 
806
}
 
807
 
 
808
static const string make_bookmark_name(const string &plugin, const char *name, int flags)
 
809
{
 
810
  /* Embed the flags into the first char of the string */
 
811
  string varname(1, static_cast<char>(flags & PLUGIN_VAR_TYPEMASK));
 
812
  varname.append(plugin);
 
813
  varname.push_back('_');
 
814
  varname.append(name);
 
815
 
 
816
  for (string::iterator p= varname.begin() + 1; p != varname.end(); ++p)
 
817
  {
 
818
    if (*p == '-')
 
819
    {
 
820
      *p= '_';
 
821
    }
 
822
  }
 
823
  return varname;
 
824
}
 
825
 
 
826
/*
 
827
  called by register_var, construct_options and test_plugin_options.
 
828
  Returns the 'bookmark' for the named variable.
 
829
  LOCK_system_variables_hash should be at least read locked
 
830
*/
 
831
static st_bookmark *find_bookmark(const string &plugin, const char *name, int flags)
 
832
{
 
833
  st_bookmark *result= NULL;
 
834
 
 
835
  if (!(flags & PLUGIN_VAR_SessionLOCAL))
 
836
    return NULL;
 
837
 
 
838
  const string varname(make_bookmark_name(plugin, name, flags));
 
839
 
 
840
 
 
841
  result= (st_bookmark*) hash_search(&bookmark_hash,
 
842
                                     (const unsigned char*) varname.c_str(), varname.size() - 1);
 
843
 
 
844
  return result;
 
845
}
 
846
 
 
847
 
 
848
/*
 
849
  returns a bookmark for session-local variables, creating if neccessary.
 
850
  returns null for non session-local variables.
 
851
  Requires that a write lock is obtained on LOCK_system_variables_hash
 
852
*/
 
853
static st_bookmark *register_var(const string &plugin, const char *name,
 
854
                                 int flags)
 
855
{
 
856
  if (!(flags & PLUGIN_VAR_SessionLOCAL))
 
857
    return NULL;
 
858
 
 
859
  uint32_t size= 0, offset, new_size;
 
860
  st_bookmark *result;
 
861
 
 
862
  switch (flags & PLUGIN_VAR_TYPEMASK) {
 
863
  case PLUGIN_VAR_BOOL:
 
864
    size= ALIGN_SIZE(sizeof(bool));
 
865
    break;
 
866
  case PLUGIN_VAR_INT:
 
867
    size= ALIGN_SIZE(sizeof(int));
 
868
    break;
 
869
  case PLUGIN_VAR_LONG:
 
870
    size= ALIGN_SIZE(sizeof(long));
 
871
    break;
 
872
  case PLUGIN_VAR_LONGLONG:
 
873
    size= ALIGN_SIZE(sizeof(uint64_t));
 
874
    break;
 
875
  case PLUGIN_VAR_STR:
 
876
    size= ALIGN_SIZE(sizeof(char*));
 
877
    break;
 
878
  default:
 
879
    assert(0);
 
880
    return NULL;
 
881
  };
 
882
 
 
883
 
 
884
  if (!(result= find_bookmark(plugin, name, flags)))
 
885
  {
 
886
    const string varname(make_bookmark_name(plugin, name, flags));
 
887
 
 
888
    result= static_cast<st_bookmark*>(plugin_mem_root.alloc_root(sizeof(struct st_bookmark) + varname.size() + 1));
 
889
    memset(result->key, 0, varname.size()+1);
 
890
    memcpy(result->key, varname.c_str(), varname.size());
 
891
    result->name_len= varname.size() - 2;
 
892
    result->offset= -1;
 
893
 
 
894
    assert(size && !(size & (size-1))); /* must be power of 2 */
 
895
 
 
896
    offset= global_system_variables.dynamic_variables_size;
 
897
    offset= (offset + size - 1) & ~(size - 1);
 
898
    result->offset= (int) offset;
 
899
 
 
900
    new_size= (offset + size + 63) & ~63;
 
901
 
 
902
    if (new_size > global_variables_dynamic_size)
 
903
    {
 
904
      char* tmpptr= NULL;
 
905
      if (!(tmpptr=
 
906
              (char *)realloc(global_system_variables.dynamic_variables_ptr,
 
907
                              new_size)))
 
908
        return NULL;
 
909
      global_system_variables.dynamic_variables_ptr= tmpptr;
 
910
      tmpptr= NULL;
 
911
      if (!(tmpptr=
 
912
              (char *)realloc(max_system_variables.dynamic_variables_ptr,
 
913
                              new_size)))
 
914
        return NULL;
 
915
      max_system_variables.dynamic_variables_ptr= tmpptr;
 
916
           
 
917
      /*
 
918
        Clear the new variable value space. This is required for string
 
919
        variables. If their value is non-NULL, it must point to a valid
 
920
        string.
 
921
      */
 
922
      memset(global_system_variables.dynamic_variables_ptr +
 
923
             global_variables_dynamic_size, 0,
 
924
             new_size - global_variables_dynamic_size);
 
925
      memset(max_system_variables.dynamic_variables_ptr +
 
926
             global_variables_dynamic_size, 0,
 
927
             new_size - global_variables_dynamic_size);
 
928
      global_variables_dynamic_size= new_size;
 
929
    }
 
930
 
 
931
    global_system_variables.dynamic_variables_head= offset;
 
932
    max_system_variables.dynamic_variables_head= offset;
 
933
    global_system_variables.dynamic_variables_size= offset + size;
 
934
    max_system_variables.dynamic_variables_size= offset + size;
 
935
    global_system_variables.dynamic_variables_version++;
 
936
    max_system_variables.dynamic_variables_version++;
 
937
 
 
938
    result->version= global_system_variables.dynamic_variables_version;
 
939
 
 
940
    /* this should succeed because we have already checked if a dup exists */
 
941
    if (my_hash_insert(&bookmark_hash, (unsigned char*) result))
 
942
    {
 
943
      fprintf(stderr, "failed to add placeholder to hash");
 
944
      assert(0);
 
945
    }
 
946
  }
 
947
  return result;
 
948
}
 
949
 
 
950
 
 
951
/*
 
952
  returns a pointer to the memory which holds the session-local variable or
 
953
  a pointer to the global variable if session==null.
 
954
  If required, will sync with global variables if the requested variable
 
955
  has not yet been allocated in the current thread.
 
956
*/
 
957
static unsigned char *intern_sys_var_ptr(Session* session, int offset, bool global_lock)
 
958
{
 
959
  assert(offset >= 0);
 
960
  assert((uint32_t)offset <= global_system_variables.dynamic_variables_head);
 
961
 
 
962
  if (!session)
 
963
    return (unsigned char*) global_system_variables.dynamic_variables_ptr + offset;
 
964
 
 
965
  /*
 
966
    dynamic_variables_head points to the largest valid offset
 
967
  */
 
968
  if (!session->variables.dynamic_variables_ptr ||
 
969
      (uint32_t)offset > session->variables.dynamic_variables_head)
 
970
  {
 
971
    uint32_t idx;
 
972
 
 
973
    char *tmpptr= NULL;
 
974
    if (!(tmpptr= (char *)realloc(session->variables.dynamic_variables_ptr,
 
975
                                  global_variables_dynamic_size)))
 
976
      return NULL;
 
977
    session->variables.dynamic_variables_ptr= tmpptr;
 
978
 
 
979
    if (global_lock)
 
980
      LOCK_global_system_variables.lock();
 
981
 
 
982
    //safe_mutex_assert_owner(&LOCK_global_system_variables);
 
983
 
 
984
    memcpy(session->variables.dynamic_variables_ptr +
 
985
             session->variables.dynamic_variables_size,
 
986
           global_system_variables.dynamic_variables_ptr +
 
987
             session->variables.dynamic_variables_size,
 
988
           global_system_variables.dynamic_variables_size -
 
989
             session->variables.dynamic_variables_size);
 
990
 
 
991
    /*
 
992
      now we need to iterate through any newly copied 'defaults'
 
993
      and if it is a string type with MEMALLOC flag, we need to strdup
 
994
    */
 
995
    for (idx= 0; idx < bookmark_hash.records; idx++)
 
996
    {
 
997
      sys_var_pluginvar *pi;
 
998
      sys_var *var;
 
999
      st_bookmark *v= (st_bookmark*) hash_element(&bookmark_hash,idx);
 
1000
 
 
1001
      if (v->version <= session->variables.dynamic_variables_version ||
 
1002
          !(var= intern_find_sys_var(v->key + 1, v->name_len, true)) ||
 
1003
          !(pi= var->cast_pluginvar()) ||
 
1004
          v->key[0] != (pi->plugin_var->flags & PLUGIN_VAR_TYPEMASK))
 
1005
        continue;
 
1006
 
 
1007
      /* Here we do anything special that may be required of the data types */
 
1008
 
 
1009
      if ((pi->plugin_var->flags & PLUGIN_VAR_TYPEMASK) == PLUGIN_VAR_STR &&
 
1010
          pi->plugin_var->flags & PLUGIN_VAR_MEMALLOC)
 
1011
      {
 
1012
         char **pp= (char**) (session->variables.dynamic_variables_ptr +
 
1013
                             *(int*)(pi->plugin_var + 1));
 
1014
         if ((*pp= *(char**) (global_system_variables.dynamic_variables_ptr +
 
1015
                             *(int*)(pi->plugin_var + 1))))
 
1016
           *pp= strdup(*pp);
 
1017
         if (*pp == NULL)
 
1018
           return NULL;
 
1019
      }
 
1020
    }
 
1021
 
 
1022
    if (global_lock)
 
1023
      LOCK_global_system_variables.unlock();
 
1024
 
 
1025
    session->variables.dynamic_variables_version=
 
1026
           global_system_variables.dynamic_variables_version;
 
1027
    session->variables.dynamic_variables_head=
 
1028
           global_system_variables.dynamic_variables_head;
 
1029
    session->variables.dynamic_variables_size=
 
1030
           global_system_variables.dynamic_variables_size;
 
1031
  }
 
1032
  return (unsigned char*)session->variables.dynamic_variables_ptr + offset;
 
1033
}
 
1034
 
 
1035
static bool *mysql_sys_var_ptr_bool(Session* a_session, int offset)
 
1036
{
 
1037
  return (bool *)intern_sys_var_ptr(a_session, offset, true);
 
1038
}
 
1039
 
 
1040
static int *mysql_sys_var_ptr_int(Session* a_session, int offset)
 
1041
{
 
1042
  return (int *)intern_sys_var_ptr(a_session, offset, true);
 
1043
}
 
1044
 
 
1045
static long *mysql_sys_var_ptr_long(Session* a_session, int offset)
 
1046
{
 
1047
  return (long *)intern_sys_var_ptr(a_session, offset, true);
 
1048
}
 
1049
 
 
1050
static int64_t *mysql_sys_var_ptr_int64_t(Session* a_session, int offset)
 
1051
{
 
1052
  return (int64_t *)intern_sys_var_ptr(a_session, offset, true);
 
1053
}
 
1054
 
 
1055
static char **mysql_sys_var_ptr_str(Session* a_session, int offset)
 
1056
{
 
1057
  return (char **)intern_sys_var_ptr(a_session, offset, true);
 
1058
}
512
1059
 
513
1060
void plugin_sessionvar_init(Session *session)
514
1061
{
515
1062
  session->variables.storage_engine= NULL;
516
 
  cleanup_variables(&session->variables);
 
1063
  cleanup_variables(session, &session->variables);
517
1064
 
518
1065
  session->variables= global_system_variables;
519
1066
  session->variables.storage_engine= NULL;
530
1077
/*
531
1078
  Unlocks all system variables which hold a reference
532
1079
*/
533
 
static void unlock_variables(Session *, struct drizzle_system_variables *vars)
 
1080
static void unlock_variables(Session *, struct system_variables *vars)
534
1081
{
535
1082
  vars->storage_engine= NULL;
536
1083
}
542
1089
  Unlike plugin_vars_free_values() it frees all variables of all plugins,
543
1090
  it's used on shutdown.
544
1091
*/
545
 
static void cleanup_variables(drizzle_system_variables *vars)
 
1092
static void cleanup_variables(Session *session, struct system_variables *vars)
546
1093
{
 
1094
  st_bookmark *v;
 
1095
  sys_var_pluginvar *pivar;
 
1096
  sys_var *var;
 
1097
  int flags;
 
1098
 
 
1099
  for (uint32_t idx= 0; idx < bookmark_hash.records; idx++)
 
1100
  {
 
1101
    v= (st_bookmark*) hash_element(&bookmark_hash, idx);
 
1102
    if (v->version > vars->dynamic_variables_version ||
 
1103
        !(var= intern_find_sys_var(v->key + 1, v->name_len, true)) ||
 
1104
        !(pivar= var->cast_pluginvar()) ||
 
1105
        v->key[0] != (pivar->plugin_var->flags & PLUGIN_VAR_TYPEMASK))
 
1106
      continue;
 
1107
 
 
1108
    flags= pivar->plugin_var->flags;
 
1109
 
 
1110
    if ((flags & PLUGIN_VAR_TYPEMASK) == PLUGIN_VAR_STR &&
 
1111
        flags & PLUGIN_VAR_SessionLOCAL && flags & PLUGIN_VAR_MEMALLOC)
 
1112
    {
 
1113
      char **ptr= (char**) pivar->real_value_ptr(session, OPT_SESSION);
 
1114
      free(*ptr);
 
1115
      *ptr= NULL;
 
1116
    }
 
1117
  }
 
1118
 
547
1119
  assert(vars->storage_engine == NULL);
548
1120
 
549
1121
  free(vars->dynamic_variables_ptr);
556
1128
void plugin_sessionvar_cleanup(Session *session)
557
1129
{
558
1130
  unlock_variables(session, &session->variables);
559
 
  cleanup_variables(&session->variables);
560
 
}
561
 
 
562
 
 
 
1131
  cleanup_variables(session, &session->variables);
 
1132
}
 
1133
 
 
1134
 
 
1135
/**
 
1136
  @brief Free values of thread variables of a plugin.
 
1137
 
 
1138
  This must be called before a plugin is deleted. Otherwise its
 
1139
  variables are no longer accessible and the value space is lost. Note
 
1140
  that only string values with PLUGIN_VAR_MEMALLOC are allocated and
 
1141
  must be freed.
 
1142
 
 
1143
  @param[in]        vars        Chain of system variables of a plugin
 
1144
*/
 
1145
 
 
1146
static void plugin_vars_free_values(sys_var *vars)
 
1147
{
 
1148
 
 
1149
  for (sys_var *var= vars; var; var= var->getNext())
 
1150
  {
 
1151
    sys_var_pluginvar *piv= var->cast_pluginvar();
 
1152
    if (piv &&
 
1153
        ((piv->plugin_var->flags & PLUGIN_VAR_TYPEMASK) == PLUGIN_VAR_STR) &&
 
1154
        (piv->plugin_var->flags & PLUGIN_VAR_MEMALLOC))
 
1155
    {
 
1156
      /* Free the string from global_system_variables. */
 
1157
      char **valptr= (char**) piv->real_value_ptr(NULL, OPT_GLOBAL);
 
1158
      free(*valptr);
 
1159
      *valptr= NULL;
 
1160
    }
 
1161
  }
 
1162
  return;
 
1163
}
 
1164
 
 
1165
 
 
1166
bool sys_var_pluginvar::check_update_type(Item_result type)
 
1167
{
 
1168
  if (is_readonly())
 
1169
    return 1;
 
1170
  switch (plugin_var->flags & PLUGIN_VAR_TYPEMASK) {
 
1171
  case PLUGIN_VAR_INT:
 
1172
  case PLUGIN_VAR_LONG:
 
1173
  case PLUGIN_VAR_LONGLONG:
 
1174
    return type != INT_RESULT;
 
1175
  case PLUGIN_VAR_STR:
 
1176
    return type != STRING_RESULT;
 
1177
  default:
 
1178
    return 0;
 
1179
  }
 
1180
}
 
1181
 
 
1182
 
 
1183
SHOW_TYPE sys_var_pluginvar::show_type()
 
1184
{
 
1185
  switch (plugin_var->flags & PLUGIN_VAR_TYPEMASK) {
 
1186
  case PLUGIN_VAR_BOOL:
 
1187
    return SHOW_MY_BOOL;
 
1188
  case PLUGIN_VAR_INT:
 
1189
    return SHOW_INT;
 
1190
  case PLUGIN_VAR_LONG:
 
1191
    return SHOW_LONG;
 
1192
  case PLUGIN_VAR_LONGLONG:
 
1193
    return SHOW_LONGLONG;
 
1194
  case PLUGIN_VAR_STR:
 
1195
    return SHOW_CHAR_PTR;
 
1196
  default:
 
1197
    assert(0);
 
1198
    return SHOW_UNDEF;
 
1199
  }
 
1200
}
 
1201
 
 
1202
 
 
1203
unsigned char* sys_var_pluginvar::real_value_ptr(Session *session, sql_var_t type)
 
1204
{
 
1205
  assert(session || (type == OPT_GLOBAL));
 
1206
  if (plugin_var->flags & PLUGIN_VAR_SessionLOCAL)
 
1207
  {
 
1208
    if (type == OPT_GLOBAL)
 
1209
      session= NULL;
 
1210
 
 
1211
    return intern_sys_var_ptr(session, *(int*) (plugin_var+1), false);
 
1212
  }
 
1213
  return *(unsigned char**) (plugin_var+1);
 
1214
}
 
1215
 
 
1216
 
 
1217
TYPELIB* sys_var_pluginvar::plugin_var_typelib(void)
 
1218
{
 
1219
  switch (plugin_var->flags & (PLUGIN_VAR_TYPEMASK | PLUGIN_VAR_SessionLOCAL)) {
 
1220
  case PLUGIN_VAR_SessionLOCAL:
 
1221
    return ((sessionvar_enum_t *)plugin_var)->typelib;
 
1222
  default:
 
1223
    return NULL;
 
1224
  }
 
1225
  return NULL;
 
1226
}
 
1227
 
 
1228
 
 
1229
unsigned char* sys_var_pluginvar::value_ptr(Session *session, sql_var_t type, const LEX_STRING *)
 
1230
{
 
1231
  unsigned char* result;
 
1232
 
 
1233
  result= real_value_ptr(session, type);
 
1234
 
 
1235
  return result;
 
1236
}
 
1237
 
 
1238
 
 
1239
bool sys_var_pluginvar::check(Session *session, set_var *var)
 
1240
{
 
1241
  st_item_value_holder value;
 
1242
  assert(is_readonly() || plugin_var->check);
 
1243
 
 
1244
  value.value_type= item_value_type;
 
1245
  value.val_str= item_val_str;
 
1246
  value.val_int= item_val_int;
 
1247
  value.val_real= item_val_real;
 
1248
  value.item= var->value;
 
1249
 
 
1250
  return is_readonly() ||
 
1251
         plugin_var->check(session, plugin_var, &var->save_result, &value);
 
1252
}
 
1253
 
 
1254
 
 
1255
void sys_var_pluginvar::set_default(Session *session, sql_var_t type)
 
1256
{
 
1257
  const void *src;
 
1258
  void *tgt;
 
1259
 
 
1260
  assert(is_readonly() || plugin_var->update);
 
1261
 
 
1262
  if (is_readonly())
 
1263
    return;
 
1264
 
 
1265
  LOCK_global_system_variables.lock();
 
1266
  tgt= real_value_ptr(session, type);
 
1267
  src= ((void **) (plugin_var + 1) + 1);
 
1268
 
 
1269
  if (plugin_var->flags & PLUGIN_VAR_SessionLOCAL)
 
1270
  {
 
1271
    if (type != OPT_GLOBAL)
 
1272
      src= real_value_ptr(session, OPT_GLOBAL);
 
1273
    else
 
1274
    switch (plugin_var->flags & PLUGIN_VAR_TYPEMASK) {
 
1275
        case PLUGIN_VAR_INT:
 
1276
          src= &((sessionvar_uint_t*) plugin_var)->def_val;
 
1277
          break;
 
1278
        case PLUGIN_VAR_LONG:
 
1279
          src= &((sessionvar_ulong_t*) plugin_var)->def_val;
 
1280
          break;
 
1281
        case PLUGIN_VAR_LONGLONG:
 
1282
          src= &((sessionvar_uint64_t_t*) plugin_var)->def_val;
 
1283
          break;
 
1284
        case PLUGIN_VAR_BOOL:
 
1285
          src= &((sessionvar_bool_t*) plugin_var)->def_val;
 
1286
          break;
 
1287
        case PLUGIN_VAR_STR:
 
1288
          src= &((sessionvar_str_t*) plugin_var)->def_val;
 
1289
          break;
 
1290
        default:
 
1291
          assert(0);
 
1292
        }
 
1293
  }
 
1294
 
 
1295
  /* session must equal current_session if PLUGIN_VAR_SessionLOCAL flag is set */
 
1296
  assert(!(plugin_var->flags & PLUGIN_VAR_SessionLOCAL) ||
 
1297
              session == current_session);
 
1298
 
 
1299
  if (!(plugin_var->flags & PLUGIN_VAR_SessionLOCAL) || type == OPT_GLOBAL)
 
1300
  {
 
1301
    plugin_var->update(session, plugin_var, tgt, src);
 
1302
    LOCK_global_system_variables.unlock();
 
1303
  }
 
1304
  else
 
1305
  {
 
1306
    LOCK_global_system_variables.unlock();
 
1307
    plugin_var->update(session, plugin_var, tgt, src);
 
1308
  }
 
1309
}
 
1310
 
 
1311
 
 
1312
bool sys_var_pluginvar::update(Session *session, set_var *var)
 
1313
{
 
1314
  void *tgt;
 
1315
 
 
1316
  assert(is_readonly() || plugin_var->update);
 
1317
 
 
1318
  /* session must equal current_session if PLUGIN_VAR_SessionLOCAL flag is set */
 
1319
  assert(!(plugin_var->flags & PLUGIN_VAR_SessionLOCAL) ||
 
1320
              session == current_session);
 
1321
 
 
1322
  if (is_readonly())
 
1323
    return 1;
 
1324
 
 
1325
  LOCK_global_system_variables.lock();
 
1326
  tgt= real_value_ptr(session, var->type);
 
1327
 
 
1328
  if (!(plugin_var->flags & PLUGIN_VAR_SessionLOCAL) || var->type == OPT_GLOBAL)
 
1329
  {
 
1330
    /* variable we are updating has global scope, so we unlock after updating */
 
1331
    plugin_var->update(session, plugin_var, tgt, &var->save_result);
 
1332
    LOCK_global_system_variables.unlock();
 
1333
  }
 
1334
  else
 
1335
  {
 
1336
    LOCK_global_system_variables.unlock();
 
1337
    plugin_var->update(session, plugin_var, tgt, &var->save_result);
 
1338
  }
 
1339
 return 0;
 
1340
}
 
1341
 
 
1342
 
 
1343
#define OPTION_SET_LIMITS(type, options, opt) \
 
1344
  options->var_type= type;                    \
 
1345
  options->def_value= (opt)->def_val;         \
 
1346
  options->min_value= (opt)->min_val;         \
 
1347
  options->max_value= (opt)->max_val;         \
 
1348
  options->block_size= (long) (opt)->blk_sz
 
1349
 
 
1350
 
 
1351
void plugin_opt_set_limits(struct option *options,
 
1352
                                                                                                         const drizzle_sys_var *opt)
 
1353
{
 
1354
  options->sub_size= 0;
 
1355
 
 
1356
  switch (opt->flags & (PLUGIN_VAR_TYPEMASK |
 
1357
                        PLUGIN_VAR_UNSIGNED | PLUGIN_VAR_SessionLOCAL)) {
 
1358
  /* global system variables */
 
1359
  case PLUGIN_VAR_INT:
 
1360
    OPTION_SET_LIMITS(GET_INT, options, (sysvar_int_t*) opt);
 
1361
    break;
 
1362
  case PLUGIN_VAR_INT | PLUGIN_VAR_UNSIGNED:
 
1363
    OPTION_SET_LIMITS(GET_UINT, options, (sysvar_uint_t*) opt);
 
1364
    break;
 
1365
  case PLUGIN_VAR_LONG:
 
1366
    OPTION_SET_LIMITS(GET_LONG, options, (sysvar_long_t*) opt);
 
1367
    break;
 
1368
  case PLUGIN_VAR_LONG | PLUGIN_VAR_UNSIGNED:
 
1369
    OPTION_SET_LIMITS(GET_ULONG_IS_FAIL, options, (sysvar_ulong_t*) opt);
 
1370
    break;
 
1371
  case PLUGIN_VAR_LONGLONG:
 
1372
    OPTION_SET_LIMITS(GET_LL, options, (sysvar_int64_t_t*) opt);
 
1373
    break;
 
1374
  case PLUGIN_VAR_LONGLONG | PLUGIN_VAR_UNSIGNED:
 
1375
    OPTION_SET_LIMITS(GET_ULL, options, (sysvar_uint64_t_t*) opt);
 
1376
    break;
 
1377
  case PLUGIN_VAR_BOOL:
 
1378
    options->var_type= GET_BOOL;
 
1379
    options->def_value= ((sysvar_bool_t*) opt)->def_val;
 
1380
    break;
 
1381
  case PLUGIN_VAR_STR:
 
1382
    options->var_type= ((opt->flags & PLUGIN_VAR_MEMALLOC) ?
 
1383
                        GET_STR_ALLOC : GET_STR);
 
1384
    options->def_value= (intptr_t) ((sysvar_str_t*) opt)->def_val;
 
1385
    break;
 
1386
  /* threadlocal variables */
 
1387
  case PLUGIN_VAR_INT | PLUGIN_VAR_SessionLOCAL:
 
1388
    OPTION_SET_LIMITS(GET_INT, options, (sessionvar_int_t*) opt);
 
1389
    break;
 
1390
  case PLUGIN_VAR_INT | PLUGIN_VAR_UNSIGNED | PLUGIN_VAR_SessionLOCAL:
 
1391
    OPTION_SET_LIMITS(GET_UINT, options, (sessionvar_uint_t*) opt);
 
1392
    break;
 
1393
  case PLUGIN_VAR_LONG | PLUGIN_VAR_SessionLOCAL:
 
1394
    OPTION_SET_LIMITS(GET_LONG, options, (sessionvar_long_t*) opt);
 
1395
    break;
 
1396
  case PLUGIN_VAR_LONG | PLUGIN_VAR_UNSIGNED | PLUGIN_VAR_SessionLOCAL:
 
1397
    OPTION_SET_LIMITS(GET_ULONG_IS_FAIL, options, (sessionvar_ulong_t*) opt);
 
1398
    break;
 
1399
  case PLUGIN_VAR_LONGLONG | PLUGIN_VAR_SessionLOCAL:
 
1400
    OPTION_SET_LIMITS(GET_LL, options, (sessionvar_int64_t_t*) opt);
 
1401
    break;
 
1402
  case PLUGIN_VAR_LONGLONG | PLUGIN_VAR_UNSIGNED | PLUGIN_VAR_SessionLOCAL:
 
1403
    OPTION_SET_LIMITS(GET_ULL, options, (sessionvar_uint64_t_t*) opt);
 
1404
    break;
 
1405
  case PLUGIN_VAR_BOOL | PLUGIN_VAR_SessionLOCAL:
 
1406
    options->var_type= GET_BOOL;
 
1407
    options->def_value= ((sessionvar_bool_t*) opt)->def_val;
 
1408
    break;
 
1409
  case PLUGIN_VAR_STR | PLUGIN_VAR_SessionLOCAL:
 
1410
    options->var_type= ((opt->flags & PLUGIN_VAR_MEMALLOC) ?
 
1411
                        GET_STR_ALLOC : GET_STR);
 
1412
    options->def_value= (intptr_t) ((sessionvar_str_t*) opt)->def_val;
 
1413
    break;
 
1414
  default:
 
1415
    assert(0);
 
1416
  }
 
1417
  options->arg_type= REQUIRED_ARG;
 
1418
  if (opt->flags & PLUGIN_VAR_NOCMDARG)
 
1419
    options->arg_type= NO_ARG;
 
1420
  if (opt->flags & PLUGIN_VAR_OPCMDARG)
 
1421
    options->arg_type= OPT_ARG;
 
1422
}
 
1423
 
 
1424
static int get_one_plugin_option(int, const struct option *, char *)
 
1425
{
 
1426
  return 0;
 
1427
}
 
1428
 
 
1429
 
 
1430
static int construct_options(memory::Root *mem_root, module::Module *tmp,
 
1431
                             option *options)
 
1432
{
 
1433
  
 
1434
  int localoptionid= 256;
 
1435
  const string plugin_name(tmp->getManifest().name);
 
1436
 
 
1437
  size_t namelen= plugin_name.size(), optnamelen;
 
1438
 
 
1439
  char *optname, *p;
 
1440
  int index= 0, offset= 0;
 
1441
  drizzle_sys_var *opt, **plugin_option;
 
1442
  st_bookmark *v;
 
1443
 
 
1444
  string name(plugin_name);
 
1445
  transform(name.begin(), name.end(), name.begin(), ::tolower);
 
1446
 
 
1447
  for (string::iterator iter= name.begin(); iter != name.end(); ++iter)
 
1448
  {
 
1449
    if (*iter == '_')
 
1450
      *iter= '-';
 
1451
  }
 
1452
 
 
1453
  /*
 
1454
    Two passes as the 2nd pass will take pointer addresses for use
 
1455
    by my_getopt and register_var() in the first pass uses realloc
 
1456
  */
 
1457
 
 
1458
  for (plugin_option= tmp->getManifest().system_vars;
 
1459
       plugin_option && *plugin_option; plugin_option++, index++)
 
1460
  {
 
1461
    opt= *plugin_option;
 
1462
    if (!(opt->flags & PLUGIN_VAR_SessionLOCAL))
 
1463
      continue;
 
1464
    if (!(register_var(name, opt->name, opt->flags)))
 
1465
      continue;
 
1466
    switch (opt->flags & PLUGIN_VAR_TYPEMASK) {
 
1467
    case PLUGIN_VAR_BOOL:
 
1468
      (((sessionvar_bool_t *)opt)->resolve)= mysql_sys_var_ptr_bool;
 
1469
      break;
 
1470
    case PLUGIN_VAR_INT:
 
1471
      (((sessionvar_int_t *)opt)->resolve)= mysql_sys_var_ptr_int;
 
1472
      break;
 
1473
    case PLUGIN_VAR_LONG:
 
1474
      (((sessionvar_long_t *)opt)->resolve)= mysql_sys_var_ptr_long;
 
1475
      break;
 
1476
    case PLUGIN_VAR_LONGLONG:
 
1477
      (((sessionvar_int64_t_t *)opt)->resolve)= mysql_sys_var_ptr_int64_t;
 
1478
      break;
 
1479
    case PLUGIN_VAR_STR:
 
1480
      (((sessionvar_str_t *)opt)->resolve)= mysql_sys_var_ptr_str;
 
1481
      break;
 
1482
    default:
 
1483
      errmsg_printf(ERRMSG_LVL_ERROR, _("Unknown variable type code 0x%x in plugin '%s'."),
 
1484
                      opt->flags, plugin_name.c_str());
 
1485
      return(-1);
 
1486
    };
 
1487
  }
 
1488
 
 
1489
  for (plugin_option= tmp->getManifest().system_vars;
 
1490
       plugin_option && *plugin_option; plugin_option++, index++)
 
1491
  {
 
1492
    switch ((opt= *plugin_option)->flags & PLUGIN_VAR_TYPEMASK) {
 
1493
    case PLUGIN_VAR_BOOL:
 
1494
      if (!opt->check)
 
1495
        opt->check= check_func_bool;
 
1496
      if (!opt->update)
 
1497
        opt->update= update_func_bool;
 
1498
      break;
 
1499
    case PLUGIN_VAR_INT:
 
1500
      if (!opt->check)
 
1501
        opt->check= check_func_int;
 
1502
      if (!opt->update)
 
1503
        opt->update= update_func_int;
 
1504
      break;
 
1505
    case PLUGIN_VAR_LONG:
 
1506
      if (!opt->check)
 
1507
        opt->check= check_func_long;
 
1508
      if (!opt->update)
 
1509
        opt->update= update_func_long;
 
1510
      break;
 
1511
    case PLUGIN_VAR_LONGLONG:
 
1512
      if (!opt->check)
 
1513
        opt->check= check_func_int64_t;
 
1514
      if (!opt->update)
 
1515
        opt->update= update_func_int64_t;
 
1516
      break;
 
1517
    case PLUGIN_VAR_STR:
 
1518
      if (!opt->check)
 
1519
        opt->check= check_func_str;
 
1520
      if (!opt->update)
 
1521
      {
 
1522
        opt->update= update_func_str;
 
1523
        if ((opt->flags & (PLUGIN_VAR_MEMALLOC | PLUGIN_VAR_READONLY)) == false)
 
1524
        {
 
1525
          opt->flags|= PLUGIN_VAR_READONLY;
 
1526
          errmsg_printf(ERRMSG_LVL_WARN, _("Server variable %s of plugin %s was forced "
 
1527
                            "to be read-only: string variable without "
 
1528
                            "update_func and PLUGIN_VAR_MEMALLOC flag"),
 
1529
                            opt->name, plugin_name.c_str());
 
1530
        }
 
1531
      }
 
1532
      break;
 
1533
    default:
 
1534
      errmsg_printf(ERRMSG_LVL_ERROR, _("Unknown variable type code 0x%x in plugin '%s'."),
 
1535
                      opt->flags, plugin_name.c_str());
 
1536
      return(-1);
 
1537
    }
 
1538
 
 
1539
    if ((opt->flags & (PLUGIN_VAR_NOCMDOPT | PLUGIN_VAR_SessionLOCAL))
 
1540
                    == PLUGIN_VAR_NOCMDOPT)
 
1541
      continue;
 
1542
 
 
1543
    if (!opt->name)
 
1544
    {
 
1545
      errmsg_printf(ERRMSG_LVL_ERROR, _("Missing variable name in plugin '%s'."),
 
1546
                    plugin_name.c_str());
 
1547
      return(-1);
 
1548
    }
 
1549
 
 
1550
    if (!(opt->flags & PLUGIN_VAR_SessionLOCAL))
 
1551
    {
 
1552
      optnamelen= strlen(opt->name);
 
1553
      optname= (char*) mem_root->alloc_root(namelen + optnamelen + 2);
 
1554
      sprintf(optname, "%s-%s", name.c_str(), opt->name);
 
1555
      optnamelen= namelen + optnamelen + 1;
 
1556
    }
 
1557
    else
 
1558
    {
 
1559
      /* this should not fail because register_var should create entry */
 
1560
      if (!(v= find_bookmark(name, opt->name, opt->flags)))
 
1561
      {
 
1562
        errmsg_printf(ERRMSG_LVL_ERROR, _("Thread local variable '%s' not allocated "
 
1563
                      "in plugin '%s'."), opt->name, plugin_name.c_str());
 
1564
        return(-1);
 
1565
      }
 
1566
 
 
1567
      *(int*)(opt + 1)= offset= v->offset;
 
1568
 
 
1569
      if (opt->flags & PLUGIN_VAR_NOCMDOPT)
 
1570
        continue;
 
1571
 
 
1572
      optname= (char*) mem_root->memdup_root(v->key + 1, (optnamelen= v->name_len) + 1);
 
1573
    }
 
1574
 
 
1575
    /* convert '_' to '-' */
 
1576
    for (p= optname; *p; p++)
 
1577
      if (*p == '_')
 
1578
        *p= '-';
 
1579
 
 
1580
    options->name= optname;
 
1581
    options->comment= opt->comment;
 
1582
    options->app_type= opt;
 
1583
    options->id= localoptionid++;
 
1584
 
 
1585
    plugin_opt_set_limits(options, opt);
 
1586
 
 
1587
    if (opt->flags & PLUGIN_VAR_SessionLOCAL)
 
1588
      options->value= options->u_max_value= (char**)
 
1589
        (global_system_variables.dynamic_variables_ptr + offset);
 
1590
    else
 
1591
      options->value= options->u_max_value= *(char***) (opt + 1);
 
1592
 
 
1593
    options++;
 
1594
  }
 
1595
 
 
1596
  return(0);
 
1597
}
 
1598
 
 
1599
 
 
1600
static option *construct_help_options(memory::Root *mem_root, module::Module *p)
 
1601
{
 
1602
  drizzle_sys_var **opt;
 
1603
  option *opts;
 
1604
  uint32_t count= EXTRA_OPTIONS;
 
1605
 
 
1606
  for (opt= p->getManifest().system_vars; opt && *opt; opt++, count++) {};
 
1607
 
 
1608
  opts= (option*)mem_root->alloc_root((sizeof(option) * count));
 
1609
  if (opts == NULL)
 
1610
    return NULL;
 
1611
 
 
1612
  memset(opts, 0, sizeof(option) * count);
 
1613
 
 
1614
  if (construct_options(mem_root, p, opts))
 
1615
    return NULL;
 
1616
 
 
1617
  return(opts);
 
1618
}
 
1619
 
 
1620
void drizzle_add_plugin_sysvar(sys_var_pluginvar *var)
 
1621
{
 
1622
  plugin_sysvar_vec.push_back(var);
 
1623
}
 
1624
 
 
1625
void drizzle_del_plugin_sysvar()
 
1626
{
 
1627
  vector<sys_var_pluginvar *>::iterator iter= plugin_sysvar_vec.begin();
 
1628
  while(iter != plugin_sysvar_vec.end())
 
1629
  {
 
1630
    delete *iter;
 
1631
    ++iter;
 
1632
  }
 
1633
  plugin_sysvar_vec.clear();
 
1634
}
563
1635
 
564
1636
/*
565
1637
  SYNOPSIS
566
1638
    test_plugin_options()
567
1639
    tmp_root                    temporary scratch space
568
1640
    plugin                      internal plugin structure
 
1641
    argc                        user supplied arguments
 
1642
    argv                        user supplied arguments
569
1643
    default_enabled             default plugin enable status
570
1644
  RETURNS:
571
1645
    0 SUCCESS - plugin should be enabled/loaded
572
1646
  NOTE:
573
1647
    Requires that a write-lock is held on LOCK_system_variables_hash
574
1648
*/
575
 
static int test_plugin_options(memory::Root *,
 
1649
static int test_plugin_options(memory::Root *module_root,
576
1650
                               module::Module *test_module,
 
1651
                               int *argc, char **argv,
577
1652
                               po::options_description &long_options)
578
1653
{
 
1654
  struct sys_var_chain chain= { NULL, NULL };
 
1655
  drizzle_sys_var **opt;
 
1656
  option *opts= NULL;
 
1657
  int error;
 
1658
  drizzle_sys_var *o;
 
1659
  struct st_bookmark *var;
 
1660
  uint32_t len, count= EXTRA_OPTIONS;
579
1661
 
580
1662
  if (test_module->getManifest().init_options != NULL)
581
1663
  {
586
1668
                                   module_options.add_options());
587
1669
    test_module->getManifest().init_options(opt_ctx);
588
1670
    long_options.add(module_options);
589
 
  }
590
 
 
591
 
  return 0;
 
1671
 
 
1672
  }
 
1673
 
 
1674
  for (opt= test_module->getManifest().system_vars; opt && *opt; opt++)
 
1675
  {
 
1676
    count++;
 
1677
  }
 
1678
 
 
1679
  if (count > EXTRA_OPTIONS || (*argc > 1))
 
1680
  {
 
1681
    if (!(opts= (option*) module_root->alloc_root(sizeof(option) * count)))
 
1682
    {
 
1683
      errmsg_printf(ERRMSG_LVL_ERROR,
 
1684
                    _("Out of memory for plugin '%s'."),
 
1685
                    test_module->getName().c_str());
 
1686
      return(-1);
 
1687
    }
 
1688
    memset(opts, 0, sizeof(option) * count);
 
1689
 
 
1690
    if (construct_options(module_root, test_module, opts))
 
1691
    {
 
1692
      errmsg_printf(ERRMSG_LVL_ERROR,
 
1693
                    _("Bad options for plugin '%s'."),
 
1694
                    test_module->getName().c_str());
 
1695
      return(-1);
 
1696
    }
 
1697
 
 
1698
    if (test_module->getManifest().init_options == NULL)
 
1699
    {
 
1700
      error= handle_options(argc, &argv, opts, get_one_plugin_option);
 
1701
      (*argc)++; /* add back one for the program name */
 
1702
 
 
1703
      if (error)
 
1704
      {
 
1705
        errmsg_printf(ERRMSG_LVL_ERROR,
 
1706
                      _("Parsing options for plugin '%s' failed."),
 
1707
                      test_module->getName().c_str());
 
1708
        goto err;
 
1709
      }
 
1710
    }
 
1711
  }
 
1712
 
 
1713
  error= 1;
 
1714
 
 
1715
  {
 
1716
    for (opt= test_module->getManifest().system_vars; opt && *opt; opt++)
 
1717
    {
 
1718
      sys_var *v;
 
1719
      if (((o= *opt)->flags & PLUGIN_VAR_NOSYSVAR))
 
1720
        continue;
 
1721
 
 
1722
      if ((var= find_bookmark(test_module->getName(), o->name, o->flags)))
 
1723
      {
 
1724
        v= new sys_var_pluginvar(var->key + 1, o);
 
1725
      }
 
1726
      else
 
1727
      {
 
1728
        len= test_module->getName().length() + strlen(o->name) + 2;
 
1729
        string vname(test_module->getName());
 
1730
        vname.push_back('-');
 
1731
        vname.append(o->name);
 
1732
        transform(vname.begin(), vname.end(), vname.begin(), ::tolower);
 
1733
        string::iterator p= vname.begin();      
 
1734
        while  (p != vname.end())
 
1735
        {
 
1736
          if (*p == '-')
 
1737
            *p= '_';
 
1738
          ++p;
 
1739
        }
 
1740
 
 
1741
        v= new sys_var_pluginvar(vname, o);
 
1742
      }
 
1743
      assert(v); /* check that an object was actually constructed */
 
1744
 
 
1745
      drizzle_add_plugin_sysvar(static_cast<sys_var_pluginvar *>(v));
 
1746
      /*
 
1747
        Add to the chain of variables.
 
1748
        Done like this for easier debugging so that the
 
1749
        pointer to v is not lost on optimized builds.
 
1750
      */
 
1751
      v->chain_sys_var(&chain);
 
1752
    }
 
1753
    if (chain.first)
 
1754
    {
 
1755
      chain.last->setNext(NULL);
 
1756
      if (mysql_add_sys_var_chain(chain.first, NULL))
 
1757
      {
 
1758
        errmsg_printf(ERRMSG_LVL_ERROR,
 
1759
                      _("Plugin '%s' has conflicting system variables"),
 
1760
                      test_module->getName().c_str());
 
1761
        goto err;
 
1762
      }
 
1763
      test_module->system_vars= chain.first;
 
1764
    }
 
1765
    return(0);
 
1766
  }
 
1767
 
 
1768
err:
 
1769
  if (opts)
 
1770
    my_cleanup_options(opts);
 
1771
  return(error);
592
1772
}
593
1773
 
594
1774
 
606
1786
};
607
1787
 
608
1788
 
609
 
void my_print_help_inc_plugins(option *main_options)
 
1789
void my_print_help_inc_plugins(option *main_options,
 
1790
                               po::options_description &long_options)
610
1791
{
611
1792
  module::Registry &registry= module::Registry::singleton();
612
1793
  vector<option> all_options;
613
1794
  memory::Root mem_root(4096);
 
1795
  option *opt= NULL;
614
1796
 
615
1797
 
616
1798
  if (initialized)
628
1810
      if (p->getManifest().init_options != NULL)
629
1811
        continue;
630
1812
 
 
1813
      if (p->getManifest().system_vars == NULL)
 
1814
        continue;
 
1815
 
 
1816
      opt= construct_help_options(&mem_root, p);
 
1817
      if (opt == NULL)
 
1818
        continue;
 
1819
 
 
1820
      /* Only options with a non-NULL comment are displayed in help text */
 
1821
      for (;opt->id; opt++)
 
1822
      {
 
1823
        if (opt->comment)
 
1824
        {
 
1825
          all_options.push_back(*opt);
 
1826
          
 
1827
        }
 
1828
      }
631
1829
    }
632
1830
  }
633
1831
 
649
1847
  all_options.push_back(*main_options);
650
1848
 
651
1849
  my_print_help(&*(all_options.begin()));
 
1850
  cout << long_options << endl;
 
1851
  my_print_variables(&*(all_options.begin()));
652
1852
 
653
1853
  mem_root.free_root(MYF(0));
654
1854
}