← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/drizzle_protocol/drizzle_protocol.cc

  • Committer: Olaf van der Spek
  • Date: 2011-07-07 13:41:07 UTC
  • mto: This revision was merged to the branch mainline in revision 2385.
  • Revision ID: olafvdspek@gmail.com-20110707134107-6mi7pauiatxtf4oe
Rename strmake to strdup (standard name)

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/drizzle_protocol/drizzle_protocol.cc
19
19
 */
20
20
 
21
21
 
22
 
#include "config.h"
 
22
#include <config.h>
23
23
#include <drizzled/gettext.h>
24
24
#include <drizzled/error.h>
25
25
#include <drizzled/query_id.h>
26
 
#include <drizzled/sql_state.h>
27
26
#include <drizzled/session.h>
28
 
#include "drizzled/internal/my_sys.h"
29
 
#include "drizzled/internal/m_string.h"
 
27
#include <drizzled/internal/my_sys.h>
 
28
#include <drizzled/internal/m_string.h>
30
29
#include <algorithm>
31
30
#include <iostream>
32
31
#include <boost/program_options.hpp>
33
32
#include <drizzled/module/option_map.h>
34
 
#include "drizzled/util/tokenize.h"
 
33
#include <drizzled/util/tokenize.h>
35
34
#include "drizzle_protocol.h"
36
 
#include "plugin/drizzle_protocol/status_table.h"
37
35
 
38
36
namespace po= boost::program_options;
39
37
using namespace drizzled;
40
38
using namespace std;
41
39
 
42
 
namespace drizzle_plugin
43
 
{
44
 
namespace drizzle_protocol
45
 
{
 
40
namespace drizzle_plugin {
 
41
namespace drizzle_protocol {
46
42
 
47
 
std::vector<std::string> ClientDrizzleProtocol::drizzle_admin_ip_addresses;
48
43
static port_constraint port;
49
44
static timeout_constraint connect_timeout;
50
45
static timeout_constraint read_timeout;
54
49
 
55
50
static const uint32_t DRIZZLE_TCP_PORT= 4427;
56
51
 
57
 
ProtocolCounters *ListenDrizzleProtocol::drizzle_counters= new ProtocolCounters();
58
 
 
59
 
ListenDrizzleProtocol::~ListenDrizzleProtocol()
60
 
{
61
 
}
62
 
 
63
 
in_port_t ListenDrizzleProtocol::getPort(void) const
 
52
ProtocolCounters ListenDrizzleProtocol::drizzle_counters;
 
53
 
 
54
in_port_t ListenDrizzleProtocol::getPort() const
64
55
{
65
56
  return port;
66
57
}
67
58
 
68
 
void ClientDrizzleProtocol::drizzle_compose_ip_addresses(vector<string> options)
69
 
{
70
 
  for (vector<string>::iterator it= options.begin();
71
 
       it != options.end();
72
 
       ++it)
73
 
  {
74
 
    tokenize(*it, drizzle_admin_ip_addresses, ",", true);
75
 
  }
76
 
}
77
 
 
78
 
bool ClientDrizzleProtocol::isAdminAllowed(void)
79
 
{
80
 
  if (std::find(drizzle_admin_ip_addresses.begin(), drizzle_admin_ip_addresses.end(), session->user()->address()) != drizzle_admin_ip_addresses.end())
81
 
    return true;
82
 
 
83
 
  return false;
84
 
}
85
 
 
86
59
plugin::Client *ListenDrizzleProtocol::getClient(int fd)
87
60
{
88
 
  int new_fd;
89
 
  new_fd= acceptTcp(fd);
90
 
  if (new_fd == -1)
91
 
    return NULL;
92
 
 
93
 
  return new ClientDrizzleProtocol(new_fd, getCounters());
 
61
  int new_fd= acceptTcp(fd);
 
62
  return new_fd == -1 ? NULL : new ClientMySQLProtocol(new_fd, getCounters());
94
63
}
95
64
 
96
65
static int init(drizzled::module::Context &context)
97
66
{  
98
67
  const module::option_map &vm= context.getOptions();
99
68
 
100
 
  context.add(new StatusTable);
101
 
  context.add(new ListenDrizzleProtocol("drizzle_protocol", vm["bind-address"].as<std::string>(), true));
 
69
  ListenDrizzleProtocol *protocol=new ListenDrizzleProtocol("drizzle_protocol", vm["bind-address"].as<std::string>());
 
70
  protocol->addCountersToTable();
 
71
  context.add(protocol);
102
72
  context.registerVariable(new sys_var_constrained_value_readonly<in_port_t>("port", port));
103
73
  context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("connect_timeout", connect_timeout));
104
74
  context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("read_timeout", read_timeout));
105
75
  context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("write_timeout", write_timeout));
106
76
  context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("retry_count", retry_count));
107
77
  context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("buffer_length", buffer_length));
108
 
  context.registerVariable(new sys_var_const_string_val("bind_address",
109
 
                                                        vm["bind-address"].as<std::string>()));
110
 
 
111
 
  context.registerVariable(new sys_var_uint32_t_ptr("max-connections", &ListenDrizzleProtocol::drizzle_counters->max_connections));
 
78
  context.registerVariable(new sys_var_const_string_val("bind_address", vm["bind-address"].as<std::string>()));
 
79
  context.registerVariable(new sys_var_uint32_t_ptr("max-connections", &ListenDrizzleProtocol::drizzle_counters.max_connections));
112
80
 
113
81
  return 0;
114
82
}
135
103
          po::value<buffer_constraint>(&buffer_length)->default_value(16384),
136
104
          N_("Buffer length."));
137
105
  context("bind-address",
138
 
          po::value<std::string>()->default_value(""),
 
106
          po::value<std::string>()->default_value("localhost"),
139
107
          N_("Address to bind to."));
140
108
  context("max-connections",
141
 
          po::value<uint32_t>(&ListenDrizzleProtocol::drizzle_counters->max_connections)->default_value(1000),
 
109
          po::value<uint32_t>(&ListenDrizzleProtocol::drizzle_counters.max_connections)->default_value(1000),
142
110
          N_("Maximum simultaneous connections."));
143
 
  context("admin-ip-addresses",
144
 
          po::value<vector<string> >()->composing()->notifier(&ClientDrizzleProtocol::drizzle_compose_ip_addresses),
145
 
          N_("A restrictive IP address list for incoming admin connections."));
146
111
}
147
112
 
148
113
} /* namespace drizzle_protocol */