← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/mysql_protocol/mysql_protocol.cc

  • Committer: kalebral at gmail
  • Date: 2010-12-04 04:58:08 UTC
  • mto: (1971.1.2 build)
  • mto: This revision was merged to the branch mainline in revision 1972.
  • Revision ID: kalebral@gmail.com-20101204045808-acto22oxfg43m02e
a few more updates of files that did not have license or had incorrect license structure

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/mysql_protocol/mysql_protocol.cc
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems, Inc.
 
4
 *  Copyright (C) 2008 Sun Microsystems
5
5
 *
6
6
 * This program is free software; you can redistribute it and/or modify
7
7
 * it under the terms of the GNU General Public License as published by
21
21
#include <drizzled/gettext.h>
22
22
#include <drizzled/error.h>
23
23
#include <drizzled/query_id.h>
24
 
#include <drizzled/error/sql_state.h>
 
24
#include <drizzled/sql_state.h>
25
25
#include <drizzled/session.h>
26
26
#include "drizzled/internal/m_string.h"
27
27
#include <algorithm>
28
28
#include <boost/program_options.hpp>
29
29
#include <drizzled/module/option_map.h>
30
 
#include "drizzled/util/tokenize.h"
31
30
#include "errmsg.h"
32
31
#include "mysql_protocol.h"
33
32
#include "mysql_password.h"
34
33
#include "options.h"
35
 
 
36
 
#include "drizzled/identifier.h"
37
 
 
38
 
#define PROTOCOL_VERSION 10
 
34
#include "table_function.h"
39
35
 
40
36
namespace po= boost::program_options;
41
37
using namespace std;
42
38
using namespace drizzled;
43
39
 
44
 
namespace drizzle_plugin
45
 
{
 
40
#define PROTOCOL_VERSION 10
46
41
 
47
 
std::vector<std::string> ClientMySQLProtocol::mysql_admin_ip_addresses;
48
42
static const unsigned int PACKET_BUFFER_EXTRA_ALLOC= 1024;
49
 
 
50
 
static port_constraint port;
51
 
static timeout_constraint connect_timeout;
52
 
static timeout_constraint read_timeout;
53
 
static timeout_constraint write_timeout;
54
 
static retry_constraint retry_count;
55
 
static buffer_constraint buffer_length;
56
 
 
 
43
static uint32_t port;
 
44
static uint32_t connect_timeout;
 
45
static uint32_t read_timeout;
 
46
static uint32_t write_timeout;
 
47
static uint32_t retry_count;
 
48
static uint32_t buffer_length;
 
49
static char* bind_address;
57
50
static uint32_t random_seed1;
58
51
static uint32_t random_seed2;
59
52
static const uint32_t random_max= 0x3FFFFFFF;
60
53
static const double random_max_double= (double)0x3FFFFFFF;
61
54
 
62
 
 
63
 
ProtocolCounters *ListenMySQLProtocol::mysql_counters= new ProtocolCounters();
 
55
static plugin::TableFunction* mysql_status_table_function_ptr= NULL;
64
56
 
65
57
ListenMySQLProtocol::~ListenMySQLProtocol()
66
 
{ }
67
 
 
68
 
void ListenMySQLProtocol::addCountersToTable()
69
58
{
70
 
  counters.push_back(new drizzled::plugin::ListenCounter(new std::string("connection_count"), &getCounters()->connectionCount));
71
 
  counters.push_back(new drizzled::plugin::ListenCounter(new std::string("connected"), &getCounters()->connected));
72
 
  counters.push_back(new drizzled::plugin::ListenCounter(new std::string("failed_connections"), &getCounters()->failedConnections));
 
59
  /* This is strdup'd from the options */
 
60
  free(bind_address);
73
61
}
74
62
 
75
 
const std::string ListenMySQLProtocol::getHost(void) const
 
63
const char* ListenMySQLProtocol::getHost(void) const
76
64
{
77
 
  return _hostname;
 
65
  return bind_address;
78
66
}
79
67
 
80
68
in_port_t ListenMySQLProtocol::getPort(void) const
81
69
{
82
 
  return port.get();
 
70
  return (in_port_t) port;
83
71
}
84
72
 
85
73
plugin::Client *ListenMySQLProtocol::getClient(int fd)
89
77
  if (new_fd == -1)
90
78
    return NULL;
91
79
 
92
 
  return new ClientMySQLProtocol(new_fd, _using_mysql41_protocol, getCounters());
 
80
  return new (nothrow) ClientMySQLProtocol(new_fd, using_mysql41_protocol);
93
81
}
94
82
 
95
 
ClientMySQLProtocol::ClientMySQLProtocol(int fd, bool using_mysql41_protocol, ProtocolCounters *set_counters):
96
 
  is_admin_connection(false),
97
 
  _using_mysql41_protocol(using_mysql41_protocol),
98
 
  counters(set_counters)
 
83
drizzled::atomic<uint64_t> ClientMySQLProtocol::connectionCount;
 
84
drizzled::atomic<uint64_t> ClientMySQLProtocol::failedConnections;
 
85
drizzled::atomic<uint64_t> ClientMySQLProtocol::connected;
 
86
 
 
87
ClientMySQLProtocol::ClientMySQLProtocol(int fd, bool using_mysql41_protocol_arg):
 
88
  using_mysql41_protocol(using_mysql41_protocol_arg)
99
89
{
100
 
  
101
90
  net.vio= 0;
102
91
 
103
92
  if (fd == -1)
104
93
    return;
105
94
 
106
 
  if (drizzleclient_net_init_sock(&net, fd, buffer_length.get()))
 
95
  if (drizzleclient_net_init_sock(&net, fd, buffer_length))
107
96
    throw bad_alloc();
108
97
 
109
 
  drizzleclient_net_set_read_timeout(&net, read_timeout.get());
110
 
  drizzleclient_net_set_write_timeout(&net, write_timeout.get());
111
 
  net.retry_count=retry_count.get();
 
98
  drizzleclient_net_set_read_timeout(&net, read_timeout);
 
99
  drizzleclient_net_set_write_timeout(&net, write_timeout);
 
100
  net.retry_count=retry_count;
112
101
}
113
102
 
114
103
ClientMySQLProtocol::~ClientMySQLProtocol()
153
142
  { 
154
143
    drizzleclient_net_close(&net);
155
144
    drizzleclient_net_end(&net);
156
 
    if (is_admin_connection)
157
 
      counters->adminConnected.decrement();
158
 
    else
159
 
      counters->connected.decrement();
 
145
    connected.decrement();
160
146
  }
161
147
}
162
148
 
163
149
bool ClientMySQLProtocol::authenticate()
164
150
{
165
151
  bool connection_is_valid;
166
 
  if (is_admin_connection)
167
 
  {
168
 
    counters->adminConnectionCount.increment();
169
 
    counters->adminConnected.increment();
170
 
  }
171
 
  else
172
 
  {
173
 
    counters->connectionCount.increment();
174
 
    counters->connected.increment();
175
 
  }
 
152
 
 
153
  connectionCount.increment();
 
154
  connected.increment();
176
155
 
177
156
  /* Use "connect_timeout" value during connection phase */
178
 
  drizzleclient_net_set_read_timeout(&net, connect_timeout.get());
179
 
  drizzleclient_net_set_write_timeout(&net, connect_timeout.get());
 
157
  drizzleclient_net_set_read_timeout(&net, connect_timeout);
 
158
  drizzleclient_net_set_write_timeout(&net, connect_timeout);
180
159
 
181
160
  connection_is_valid= checkConnection();
182
161
 
183
162
  if (connection_is_valid)
184
 
  {
185
 
    if (not is_admin_connection and (counters->connected > counters->max_connections))
186
 
    {
187
 
      std::string errmsg(ER(ER_CON_COUNT_ERROR));
188
 
      sendError(ER_CON_COUNT_ERROR, errmsg.c_str());
189
 
      counters->failedConnections.increment();
190
 
    }
191
 
    else
192
 
    {
193
 
      sendOK();
194
 
    }
195
 
  }
 
163
    sendOK();
196
164
  else
197
165
  {
198
166
    sendError(session->main_da.sql_errno(), session->main_da.message());
199
 
    counters->failedConnections.increment();
 
167
    failedConnections.increment();
200
168
    return false;
201
169
  }
202
 
 
203
170
  /* Connect completed, set read/write timeouts back to default */
204
 
  drizzleclient_net_set_read_timeout(&net, read_timeout.get());
205
 
  drizzleclient_net_set_write_timeout(&net, write_timeout.get());
 
171
  drizzleclient_net_set_read_timeout(&net, read_timeout);
 
172
  drizzleclient_net_set_write_timeout(&net, write_timeout);
206
173
  return true;
207
174
}
208
175
 
258
225
    (*l_packet)[0]= (unsigned char) COM_SLEEP;
259
226
    *packet_length= 1;
260
227
  }
261
 
  else if (_using_mysql41_protocol)
 
228
  else if (using_mysql41_protocol)
262
229
  {
263
230
    /* Map from MySQL commands to Drizzle commands. */
264
231
    switch ((int)(*l_packet)[0])
398
365
    drizzleclient_net_flush(&net);
399
366
    session->main_da.can_overwrite_status= false;
400
367
  }
401
 
  packet.shrink(buffer_length.get());
 
368
  packet.shrink(buffer_length);
402
369
}
403
370
 
404
371
 
405
 
void ClientMySQLProtocol::sendError(drizzled::error_t sql_errno, const char *err)
 
372
void ClientMySQLProtocol::sendError(uint32_t sql_errno, const char *err)
406
373
{
407
374
  uint32_t length;
408
375
  /*
410
377
  */
411
378
  unsigned char buff[2+1+SQLSTATE_LENGTH+DRIZZLE_ERRMSG_SIZE], *pos;
412
379
 
413
 
  assert(sql_errno != EE_OK);
 
380
  assert(sql_errno);
414
381
  assert(err && err[0]);
415
382
 
416
383
  /*
435
402
    return;
436
403
  }
437
404
 
438
 
  int2store(buff, static_cast<uint16_t>(sql_errno));
 
405
  int2store(buff,sql_errno);
439
406
  pos= buff+2;
440
407
 
441
408
  /* The first # is to make the client backward compatible */
442
409
  buff[2]= '#';
443
 
  pos= (unsigned char*) strcpy((char*) buff+3, error::convert_to_sqlstate(sql_errno));
444
 
  pos+= strlen(error::convert_to_sqlstate(sql_errno));
 
410
  pos= (unsigned char*) strcpy((char*) buff+3, drizzle_errno_to_sqlstate(sql_errno));
 
411
  pos+= strlen(drizzle_errno_to_sqlstate(sql_errno));
445
412
 
446
413
  char *tmp= strncpy((char*)pos, err, DRIZZLE_ERRMSG_SIZE-1);
447
414
  tmp+= strlen((char*)pos);
508
475
    int2store(pos, field.charsetnr);
509
476
    int4store(pos+2, field.length);
510
477
 
511
 
    if (_using_mysql41_protocol)
 
478
    if (using_mysql41_protocol)
512
479
    {
513
480
      /* Switch to MySQL field numbering. */
514
481
      switch (field.type)
537
504
        pos[6]= 12;
538
505
        break;
539
506
 
540
 
      case DRIZZLE_TYPE_TIME:
541
 
        pos[6]= 13;
542
 
        break;
543
 
 
544
507
      case DRIZZLE_TYPE_DATE:
545
508
        pos[6]= 14;
546
509
        break;
549
512
        pos[6]= 15;
550
513
        break;
551
514
 
552
 
      case DRIZZLE_TYPE_MICROTIME:
553
 
        pos[6]= 15;
554
 
        break;
555
 
 
556
 
      case DRIZZLE_TYPE_UUID:
557
 
        pos[6]= 15;
558
 
        break;
559
 
 
560
 
      case DRIZZLE_TYPE_BOOLEAN:
561
 
        pos[6]= 15;
562
 
        break;
563
 
 
564
515
      case DRIZZLE_TYPE_DECIMAL:
565
516
        pos[6]= (char)246;
566
517
        break;
612
563
  char buff[MAX_FIELD_WIDTH];
613
564
  String str(buff,sizeof(buff), &my_charset_bin);
614
565
 
615
 
  from->val_str_internal(&str);
 
566
  from->val_str(&str);
616
567
 
617
568
  return netStoreData((const unsigned char *)str.ptr(), str.length());
618
569
}
683
634
  uint32_t pkt_len= 0;
684
635
  char *end;
685
636
  char scramble[SCRAMBLE_LENGTH];
686
 
  identifier::User::shared_ptr user_identifier= identifier::User::make_shared();
687
637
 
688
638
  makeScramble(scramble);
689
639
 
694
644
 
695
645
    if (drizzleclient_net_peer_addr(&net, ip, &peer_port, NI_MAXHOST))
696
646
    {
697
 
      my_error(ER_BAD_HOST_ERROR, MYF(0), ip);
 
647
      my_error(ER_BAD_HOST_ERROR, MYF(0), session->getSecurityContext().getIp().c_str());
698
648
      return false;
699
649
    }
700
650
 
701
 
    user_identifier->setAddress(ip);
 
651
    session->getSecurityContext().setIp(ip);
702
652
  }
703
653
  drizzleclient_net_keepalive(&net, true);
704
654
 
709
659
 
710
660
    server_capabilites= CLIENT_BASIC_FLAGS;
711
661
 
712
 
    if (_using_mysql41_protocol)
 
662
    if (using_mysql41_protocol)
713
663
      server_capabilites|= CLIENT_PROTOCOL_MYSQL41;
714
664
 
715
665
#ifdef HAVE_COMPRESS
753
703
        ||    (pkt_len= drizzleclient_net_read(&net)) == packet_error 
754
704
        || pkt_len < MIN_HANDSHAKE_SIZE)
755
705
    {
756
 
      my_error(ER_HANDSHAKE_ERROR, MYF(0), user_identifier->address().c_str());
 
706
      my_error(ER_HANDSHAKE_ERROR, MYF(0), session->getSecurityContext().getIp().c_str());
757
707
      return false;
758
708
    }
759
709
  }
760
 
  if (packet.alloc(buffer_length.get()))
 
710
  if (packet.alloc(buffer_length))
761
711
    return false; /* The error is set by alloc(). */
762
712
 
763
713
  client_capabilities= uint2korr(net.read_pos);
764
714
  if (!(client_capabilities & CLIENT_PROTOCOL_MYSQL41))
765
715
  {
766
 
    my_error(ER_HANDSHAKE_ERROR, MYF(0), user_identifier->address().c_str());
 
716
    my_error(ER_HANDSHAKE_ERROR, MYF(0), session->getSecurityContext().getIp().c_str());
767
717
    return false;
768
718
  }
769
719
 
779
729
 
780
730
  if (end >= (char*) net.read_pos + pkt_len + 2)
781
731
  {
782
 
    my_error(ER_HANDSHAKE_ERROR, MYF(0), user_identifier->address().c_str());
 
732
    my_error(ER_HANDSHAKE_ERROR, MYF(0), session->getSecurityContext().getIp().c_str());
783
733
    return false;
784
734
  }
785
735
 
803
753
    passwd_len= (unsigned char)(*passwd++);
804
754
    if (passwd_len > 0)
805
755
    {
806
 
      user_identifier->setPasswordType(identifier::User::MYSQL_HASH);
807
 
      user_identifier->setPasswordContext(scramble, SCRAMBLE_LENGTH);
 
756
      session->getSecurityContext().setPasswordType(SecurityContext::MYSQL_HASH);
 
757
      session->getSecurityContext().setPasswordContext(scramble, SCRAMBLE_LENGTH);
808
758
    }
809
759
  }
810
760
  else
811
 
  {
812
761
    passwd_len= 0;
813
 
  }
814
762
 
815
763
  if (client_capabilities & CLIENT_CONNECT_WITH_DB &&
816
764
      passwd < (char *) net.read_pos + pkt_len)
818
766
    l_db= l_db + passwd_len + 1;
819
767
  }
820
768
  else
821
 
  {
822
769
    l_db= NULL;
823
 
  }
824
770
 
825
771
  /* strlen() can't be easily deleted without changing client */
826
772
  uint32_t db_len= l_db ? strlen(l_db) : 0;
827
773
 
828
774
  if (passwd + passwd_len + db_len > (char *) net.read_pos + pkt_len)
829
775
  {
830
 
    my_error(ER_HANDSHAKE_ERROR, MYF(0), user_identifier->address().c_str());
 
776
    my_error(ER_HANDSHAKE_ERROR, MYF(0), session->getSecurityContext().getIp().c_str());
831
777
    return false;
832
778
  }
833
779
 
839
785
    user_len-= 2;
840
786
  }
841
787
 
842
 
  if (client_capabilities & CLIENT_ADMIN)
843
 
  {
844
 
    if ((strncmp(user, "root", 4) == 0) and isAdminAllowed())
845
 
    {
846
 
      is_admin_connection= true;
847
 
    }
848
 
    else
849
 
    {
850
 
      my_error(ER_ADMIN_ACCESS, MYF(0));
851
 
      return false;
852
 
    }
853
 
  }
854
 
 
855
 
  user_identifier->setUser(user);
856
 
  session->setUser(user_identifier);
 
788
  session->getSecurityContext().setUser(user);
857
789
 
858
790
  return session->checkUser(string(passwd, passwd_len),
859
791
                            string(l_db ? l_db : ""));
860
792
 
861
793
}
862
794
 
863
 
bool ClientMySQLProtocol::isAdminAllowed(void)
864
 
{
865
 
  if (std::find(mysql_admin_ip_addresses.begin(), mysql_admin_ip_addresses.end(), session->user()->address()) != mysql_admin_ip_addresses.end())
866
 
    return true;
867
 
 
868
 
  return false;
869
 
}
870
 
 
871
795
bool ClientMySQLProtocol::netStoreData(const unsigned char *from, size_t length)
872
796
{
873
797
  size_t packet_length= packet.length();
970
894
  }
971
895
}
972
896
 
973
 
void ClientMySQLProtocol::mysql_compose_ip_addresses(vector<string> options)
974
 
{
975
 
  for (vector<string>::iterator it= options.begin();
976
 
       it != options.end();
977
 
       ++it)
978
 
  {
979
 
    tokenize(*it, mysql_admin_ip_addresses, ",", true);
980
 
  }
981
 
}
982
 
 
983
897
static ListenMySQLProtocol *listen_obj= NULL;
984
898
plugin::Create_function<MySQLPassword> *mysql_password= NULL;
985
899
 
986
900
static int init(drizzled::module::Context &context)
987
901
{  
 
902
  mysql_status_table_function_ptr= new MysqlProtocolStatus;
 
903
 
 
904
  context.add(mysql_status_table_function_ptr);
988
905
  /* Initialize random seeds for the MySQL algorithm with minimal changes. */
989
906
  time_t seed_time= time(NULL);
990
907
  random_seed1= seed_time % random_max;
991
908
  random_seed2= (seed_time / 2) % random_max;
992
909
 
993
910
  const module::option_map &vm= context.getOptions();
 
911
  if (vm.count("port"))
 
912
  { 
 
913
    if (port > 65535)
 
914
    {
 
915
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value of port\n"));
 
916
      exit(-1);
 
917
    }
 
918
  }
 
919
 
 
920
  if (vm.count("connect-timeout"))
 
921
  {
 
922
    if (connect_timeout < 1 || connect_timeout > 300)
 
923
    {
 
924
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for connect_timeout\n"));
 
925
      exit(-1);
 
926
    }
 
927
  }
 
928
 
 
929
  if (vm.count("read-timeout"))
 
930
  {
 
931
    if (read_timeout < 1 || read_timeout > 300)
 
932
    {
 
933
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for read_timeout\n"));
 
934
      exit(-1);
 
935
    }
 
936
  }
 
937
 
 
938
  if (vm.count("write-timeout"))
 
939
  {
 
940
    if (write_timeout < 1 || write_timeout > 300)
 
941
    {
 
942
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for write_timeout\n"));
 
943
      exit(-1);
 
944
    }
 
945
  }
 
946
 
 
947
  if (vm.count("retry-count"))
 
948
  {
 
949
    if (retry_count < 1 || retry_count > 100)
 
950
    {
 
951
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for retry_count"));
 
952
      exit(-1);
 
953
    }
 
954
  }
 
955
 
 
956
  if (vm.count("buffer-length"))
 
957
  {
 
958
    if (buffer_length < 1024 || buffer_length > 1024*1024)
 
959
    {
 
960
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for buffer_length\n"));
 
961
      exit(-1);
 
962
    }
 
963
  }
 
964
 
 
965
  if (vm.count("bind-address"))
 
966
  {
 
967
    bind_address= strdup(vm["bind-address"].as<string>().c_str());
 
968
  }
 
969
 
 
970
  else
 
971
  {
 
972
    bind_address= NULL;
 
973
  }
994
974
 
995
975
  mysql_password= new plugin::Create_function<MySQLPassword>(MySQLPasswordName);
996
976
  context.add(mysql_password);
997
977
 
998
 
  listen_obj= new ListenMySQLProtocol("mysql_protocol", vm["bind-address"].as<std::string>(), true);
999
 
  listen_obj->addCountersToTable();
 
978
  listen_obj= new ListenMySQLProtocol("mysql_protocol", true);
1000
979
  context.add(listen_obj); 
1001
 
  context.registerVariable(new sys_var_constrained_value_readonly<in_port_t>("port", port));
1002
 
  context.registerVariable(new sys_var_constrained_value<uint32_t>("connect_timeout", connect_timeout));
1003
 
  context.registerVariable(new sys_var_constrained_value<uint32_t>("read_timeout", read_timeout));
1004
 
  context.registerVariable(new sys_var_constrained_value<uint32_t>("write_timeout", write_timeout));
1005
 
  context.registerVariable(new sys_var_constrained_value<uint32_t>("retry_count", retry_count));
1006
 
  context.registerVariable(new sys_var_constrained_value<uint32_t>("buffer_length", buffer_length));
1007
 
  context.registerVariable(new sys_var_const_string_val("bind_address",
1008
 
                                                        vm["bind-address"].as<std::string>()));
1009
 
 
1010
 
  context.registerVariable(new sys_var_uint32_t_ptr("max-connections", &ListenMySQLProtocol::mysql_counters->max_connections));
1011
980
 
1012
981
  return 0;
1013
982
}
1014
983
 
 
984
static DRIZZLE_SYSVAR_UINT(port, port, PLUGIN_VAR_RQCMDARG,
 
985
                           N_("Port number to use for connection or 0 for default to with MySQL "
 
986
                              "protocol."),
 
987
                           NULL, NULL, 3306, 0, 65535, 0);
 
988
static DRIZZLE_SYSVAR_UINT(connect_timeout, connect_timeout,
 
989
                           PLUGIN_VAR_RQCMDARG, N_("Connect Timeout."),
 
990
                           NULL, NULL, 10, 1, 300, 0);
 
991
static DRIZZLE_SYSVAR_UINT(read_timeout, read_timeout, PLUGIN_VAR_RQCMDARG,
 
992
                           N_("Read Timeout."), NULL, NULL, 30, 1, 300, 0);
 
993
static DRIZZLE_SYSVAR_UINT(write_timeout, write_timeout, PLUGIN_VAR_RQCMDARG,
 
994
                           N_("Write Timeout."), NULL, NULL, 60, 1, 300, 0);
 
995
static DRIZZLE_SYSVAR_UINT(retry_count, retry_count, PLUGIN_VAR_RQCMDARG,
 
996
                           N_("Retry Count."), NULL, NULL, 10, 1, 100, 0);
 
997
static DRIZZLE_SYSVAR_UINT(buffer_length, buffer_length, PLUGIN_VAR_RQCMDARG,
 
998
                           N_("Buffer length."), NULL, NULL, 16384, 1024,
 
999
                           1024*1024, 0);
 
1000
static DRIZZLE_SYSVAR_STR(bind_address, bind_address, PLUGIN_VAR_READONLY,
 
1001
                          N_("Address to bind to."), NULL, NULL, NULL);
 
1002
 
1015
1003
static void init_options(drizzled::module::option_context &context)
1016
1004
{
1017
1005
  context("port",
1018
 
          po::value<port_constraint>(&port)->default_value(3306),
1019
 
          _("Port number to use for connection or 0 for default to with MySQL "
 
1006
          po::value<uint32_t>(&port)->default_value(3306),
 
1007
          N_("Port number to use for connection or 0 for default to with MySQL "
1020
1008
                              "protocol."));
1021
1009
  context("connect-timeout",
1022
 
          po::value<timeout_constraint>(&connect_timeout)->default_value(10),
1023
 
          _("Connect Timeout."));
 
1010
          po::value<uint32_t>(&connect_timeout)->default_value(10),
 
1011
          N_("Connect Timeout."));
1024
1012
  context("read-timeout",
1025
 
          po::value<timeout_constraint>(&read_timeout)->default_value(30),
1026
 
          _("Read Timeout."));
 
1013
          po::value<uint32_t>(&read_timeout)->default_value(30),
 
1014
          N_("Read Timeout."));
1027
1015
  context("write-timeout",
1028
 
          po::value<timeout_constraint>(&write_timeout)->default_value(60),
1029
 
          _("Write Timeout."));
 
1016
          po::value<uint32_t>(&write_timeout)->default_value(60),
 
1017
          N_("Write Timeout."));
1030
1018
  context("retry-count",
1031
 
          po::value<retry_constraint>(&retry_count)->default_value(10),
1032
 
          _("Retry Count."));
 
1019
          po::value<uint32_t>(&retry_count)->default_value(10),
 
1020
          N_("Retry Count."));
1033
1021
  context("buffer-length",
1034
 
          po::value<buffer_constraint>(&buffer_length)->default_value(16384),
1035
 
          _("Buffer length."));
 
1022
          po::value<uint32_t>(&buffer_length)->default_value(16384),
 
1023
          N_("Buffer length."));
1036
1024
  context("bind-address",
1037
 
          po::value<string>()->default_value(""),
1038
 
          _("Address to bind to."));
1039
 
  context("max-connections",
1040
 
          po::value<uint32_t>(&ListenMySQLProtocol::mysql_counters->max_connections)->default_value(1000),
1041
 
          _("Maximum simultaneous connections."));
1042
 
  context("admin-ip-addresses",
1043
 
          po::value<vector<string> >()->composing()->notifier(&ClientMySQLProtocol::mysql_compose_ip_addresses),
1044
 
          _("A restrictive IP address list for incoming admin connections."));
1045
 
}
1046
 
 
1047
 
} /* namespace drizzle_plugin */
 
1025
          po::value<string>(),
 
1026
          N_("Address to bind to."));
 
1027
}
 
1028
 
 
1029
static drizzle_sys_var* sys_variables[]= {
 
1030
  DRIZZLE_SYSVAR(port),
 
1031
  DRIZZLE_SYSVAR(connect_timeout),
 
1032
  DRIZZLE_SYSVAR(read_timeout),
 
1033
  DRIZZLE_SYSVAR(write_timeout),
 
1034
  DRIZZLE_SYSVAR(retry_count),
 
1035
  DRIZZLE_SYSVAR(buffer_length),
 
1036
  DRIZZLE_SYSVAR(bind_address),
 
1037
  NULL
 
1038
};
 
1039
 
 
1040
static int mysql_protocol_connection_count_func(drizzle_show_var *var, char *buff)
 
1041
{
 
1042
  var->type= SHOW_LONGLONG;
 
1043
  var->value= buff;
 
1044
  *((uint64_t *)buff)= ClientMySQLProtocol::connectionCount;
 
1045
  return 0;
 
1046
}
 
1047
 
 
1048
static int mysql_protocol_connected_count_func(drizzle_show_var *var, char *buff)
 
1049
{
 
1050
  var->type= SHOW_LONGLONG;
 
1051
  var->value= buff;
 
1052
  *((uint64_t *)buff)= ClientMySQLProtocol::connected;
 
1053
  return 0;
 
1054
}
 
1055
 
 
1056
static int mysql_protocol_failed_count_func(drizzle_show_var *var, char *buff)
 
1057
{
 
1058
  var->type= SHOW_LONGLONG;
 
1059
  var->value= buff;
 
1060
  *((uint64_t *)buff)= ClientMySQLProtocol::failedConnections;
 
1061
  return 0;
 
1062
}
 
1063
 
 
1064
static st_show_var_func_container mysql_protocol_connection_count=
 
1065
  { &mysql_protocol_connection_count_func };
 
1066
 
 
1067
static st_show_var_func_container mysql_protocol_connected_count=
 
1068
  { &mysql_protocol_connected_count_func };
 
1069
 
 
1070
static st_show_var_func_container mysql_protocol_failed_count=
 
1071
  { &mysql_protocol_failed_count_func };
 
1072
 
 
1073
static drizzle_show_var mysql_protocol_status_variables[]= {
 
1074
  {"Connections",
 
1075
  (char*) &mysql_protocol_connection_count, SHOW_FUNC},
 
1076
  {"Connected",
 
1077
  (char*) &mysql_protocol_connected_count, SHOW_FUNC},
 
1078
  {"Failed_connections",
 
1079
  (char*) &mysql_protocol_failed_count, SHOW_FUNC},
 
1080
  {NULL, NULL, SHOW_LONGLONG}
 
1081
};
 
1082
 
 
1083
MysqlProtocolStatus::Generator::Generator(drizzled::Field **fields) :
 
1084
  plugin::TableFunction::Generator(fields)
 
1085
{
 
1086
  status_var_ptr= mysql_protocol_status_variables;
 
1087
}
 
1088
 
 
1089
bool MysqlProtocolStatus::Generator::populate()
 
1090
{
 
1091
  MY_ALIGNED_BYTE_ARRAY(buff_data, SHOW_VAR_FUNC_BUFF_SIZE, int64_t);
 
1092
  char * const buff= (char *) &buff_data;
 
1093
  drizzle_show_var tmp;
 
1094
 
 
1095
  if (status_var_ptr->name)
 
1096
  {
 
1097
    std::ostringstream oss;
 
1098
    string return_value;
 
1099
    const char *value;
 
1100
    int type;
 
1101
 
 
1102
    push(status_var_ptr->name);
 
1103
 
 
1104
    if (status_var_ptr->type == SHOW_FUNC)
 
1105
    {
 
1106
      ((drizzle_show_var_func)((st_show_var_func_container *)status_var_ptr->value)->func)(&tmp, buff);
 
1107
      value= buff;
 
1108
      type= tmp.type;
 
1109
    }
 
1110
    else
 
1111
    {
 
1112
      value= status_var_ptr->value;
 
1113
      type= status_var_ptr->type;
 
1114
    }
 
1115
 
 
1116
    switch(type)
 
1117
    {
 
1118
    case SHOW_LONGLONG:
 
1119
      oss << *(uint64_t*) value;
 
1120
      return_value= oss.str();
 
1121
      break;
 
1122
    default:
 
1123
      assert(0);
 
1124
    }
 
1125
    if (return_value.length())
 
1126
      push(return_value);
 
1127
    else
 
1128
      push(" ");
 
1129
 
 
1130
    status_var_ptr++;
 
1131
 
 
1132
    return true;
 
1133
  }
 
1134
  return false;
 
1135
}
1048
1136
 
1049
1137
DRIZZLE_DECLARE_PLUGIN
1050
1138
{
1054
1142
  "Eric Day",
1055
1143
  "MySQL Protocol Module",
1056
1144
  PLUGIN_LICENSE_GPL,
1057
 
  drizzle_plugin::init,             /* Plugin Init */
1058
 
  NULL, /* depends */
1059
 
  drizzle_plugin::init_options    /* config options */
 
1145
  init,             /* Plugin Init */
 
1146
  sys_variables, /* system variables */
 
1147
  init_options    /* config options */
1060
1148
}
1061
1149
DRIZZLE_DECLARE_PLUGIN_END;