← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/console/console.cc

  • Committer: lbieber at stabletransit
  • Date: 2010-10-18 20:26:50 UTC
  • mfrom: (1859.1.4 build)
  • Revision ID: lbieber@drizzle-build-n02.wc1.dfw1.stabletransit.com-20101018202650-hcvsp7yuaf1xy04s
Merge Monty - Adds support for a const std::string sys_var type.
Merge Monty - Make it possible to use sys_var directly from plugins.
Merge Padraig - Replaced a few unit8_t types that were being used as bitmaps with std::bitset

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/console/console.cc
31
31
 
32
32
static bool enabled= false;
33
33
static bool debug_enabled= false;
34
 
static char* username= NULL;
35
 
static char* password= NULL;
36
 
static char* db= NULL;
37
34
 
38
35
 
39
36
class ClientConsole: public plugin::Client
41
38
  bool is_dead;
42
39
  uint32_t column;
43
40
  uint32_t max_column;
 
41
  const std::string &username;
 
42
  const std::string &password;
 
43
  const std::string &db;
44
44
 
45
45
public:
46
 
  ClientConsole():
 
46
  ClientConsole(const std::string &username_arg,
 
47
                const std::string &password_arg,
 
48
                const std::string &db_arg) :
47
49
    is_dead(false),
48
50
    column(0),
49
 
    max_column(0)
 
51
    max_column(0),
 
52
    username(username_arg),
 
53
    password(password_arg),
 
54
    db(db_arg)
50
55
  {}
51
56
 
52
57
  virtual void printDebug(const char *message)
95
100
  {
96
101
    printDebug("authenticate");
97
102
    session->getSecurityContext().setUser(username);
98
 
    return session->checkUser(password, strlen(password), db);
 
103
    return session->checkUser(password, db);
99
104
  }
100
105
 
101
106
  virtual bool readCommand(char **packet, uint32_t *packet_length)
269
274
class ListenConsole: public plugin::Listen
270
275
{
271
276
  int pipe_fds[2];
 
277
  const std::string username;
 
278
  const std::string password;
 
279
  const std::string db;
272
280
 
273
281
public:
274
 
  ListenConsole(const std::string &name_arg) :
275
 
    plugin::Listen(name_arg)
 
282
  ListenConsole(const std::string &name_arg,
 
283
                const std::string &username_arg,
 
284
                const std::string &password_arg,
 
285
                const std::string &db_arg) :
 
286
    plugin::Listen(name_arg),
 
287
    username(username_arg),
 
288
    password(password_arg),
 
289
    db(db_arg)
276
290
  {
277
291
    pipe_fds[0]= -1;
278
292
  }
284
298
      close(pipe_fds[0]);
285
299
      close(pipe_fds[1]);
286
300
    }
287
 
 
288
 
    /* Cleanup from the module strdup'ing these below */
289
 
    free(username);
290
 
    free(password);
291
 
    free(db);
292
301
  }
293
302
 
294
303
  virtual bool getFileDescriptors(std::vector<int> &fds)
296
305
    if (debug_enabled)
297
306
      enabled= true;
298
307
 
299
 
    if (enabled == false)
 
308
    if (not enabled)
300
309
      return false;
301
310
 
302
311
    if (pipe(pipe_fds) == -1)
314
323
  {
315
324
    char buffer[1];
316
325
    assert(read(fd, buffer, 1) == 1);
317
 
    return new ClientConsole;
 
326
    return new ClientConsole(username, password, db);
318
327
  }
319
328
};
320
329
 
321
330
static int init(drizzled::module::Context &context)
322
331
{
323
332
  const module::option_map &vm= context.getOptions();
324
 
  /* duplicating these here means they need to be freed. They're global, so
325
 
     we'll just have the ListenConsole object do it in its destructor */
326
 
  if (vm.count("username"))
327
 
    username= strdup(vm["username"].as<string>().c_str());
328
 
  else
329
 
    username= strdup("");
330
 
 
331
 
  if (vm.count("password"))
332
 
    password= strdup(vm["password"].as<string>().c_str());
333
 
  else
334
 
    password= strdup("");
335
 
 
336
 
  if (vm.count("db"))
337
 
    db= strdup(vm["db"].as<string>().c_str());
338
 
  else
339
 
    db= strdup("");
340
 
 
341
 
  context.add(new ListenConsole("console"));
 
333
  const string username(vm.count("username") ? vm["username"].as<string>() : "");
 
334
  const string password(vm.count("password") ? vm["password"].as<string>() : "");
 
335
  const string db(vm.count("db") ? vm["db"].as<string>() : "");
 
336
  context.registerVariable(new sys_var_bool_ptr("enable", &enabled));
 
337
  context.registerVariable(new sys_var_bool_ptr("debug_enable", &debug_enabled));
 
338
  context.registerVariable(new sys_var_const_string_val("username", username));
 
339
  context.registerVariable(new sys_var_const_string_val("password", password));
 
340
  context.registerVariable(new sys_var_const_string_val("db", db));
 
341
  context.add(new ListenConsole("console", username, password, db));
342
342
  return 0;
343
343
}
344
344
 
345
 
static DRIZZLE_SYSVAR_BOOL(enable, enabled, PLUGIN_VAR_NOCMDARG,
346
 
                           N_("Enable the console."), NULL, NULL, false);
347
 
static DRIZZLE_SYSVAR_BOOL(debug, debug_enabled, PLUGIN_VAR_NOCMDARG,
348
 
                           N_("Turn on extra debugging."), NULL, NULL, false);
349
 
 
350
 
static DRIZZLE_SYSVAR_STR(username, username, PLUGIN_VAR_READONLY,
351
 
                          N_("User to use for auth."), NULL, NULL, NULL);
352
 
static DRIZZLE_SYSVAR_STR(password, password, PLUGIN_VAR_READONLY,
353
 
                          N_("Password to use for auth."), NULL, NULL, NULL);
354
 
static DRIZZLE_SYSVAR_STR(db, db, PLUGIN_VAR_READONLY,
355
 
                          N_("Default database to use."), NULL, NULL, NULL);
356
 
 
357
345
static void init_options(drizzled::module::option_context &context)
358
346
{
359
347
  context("enable",
373
361
          N_("Default database to use."));
374
362
}
375
363
 
376
 
static drizzle_sys_var* vars[]= {
377
 
  DRIZZLE_SYSVAR(enable),
378
 
  DRIZZLE_SYSVAR(debug),
379
 
  DRIZZLE_SYSVAR(username),
380
 
  DRIZZLE_SYSVAR(password),
381
 
  DRIZZLE_SYSVAR(db),
382
 
  NULL
383
 
};
384
 
 
385
364
DRIZZLE_DECLARE_PLUGIN
386
365
{
387
366
  DRIZZLE_VERSION_ID,
391
370
  "Console Client",
392
371
  PLUGIN_LICENSE_BSD,
393
372
  init,   /* Plugin Init */
394
 
  vars,   /* system variables */
 
373
  NULL,   /* system variables */
395
374
  init_options    /* config options */
396
375
}
397
376
DRIZZLE_DECLARE_PLUGIN_END;