← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/mysql_protocol/oldlibdrizzle.cc

  • Committer: Brian Aker
  • Date: 2009-12-18 18:31:01 UTC
  • mfrom: (1241.2.7 build)
  • Revision ID: brian@gaz-20091218183101-igqg1dtowpa0o70s
Fixed from Monty.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/mysql_protocol/oldlibdrizzle.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
14
14
 *
15
15
 * You should have received a copy of the GNU General Public License
16
16
 * along with this program; if not, write to the Free Software
17
 
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
18
 */
19
19
 
20
 
#include "config.h"
 
20
#include <drizzled/server_includes.h>
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
 
#include "drizzled/internal/m_string.h"
27
26
#include <algorithm>
28
 
#include <boost/program_options.hpp>
29
 
#include <drizzled/module/option_map.h>
30
 
#include "drizzled/util/tokenize.h"
 
27
 
 
28
#include "pack.h"
31
29
#include "errmsg.h"
32
 
#include "mysql_protocol.h"
33
 
#include "mysql_password.h"
 
30
#include "oldlibdrizzle.h"
34
31
#include "options.h"
35
32
 
36
 
#include "drizzled/identifier.h"
37
 
 
38
 
#define PROTOCOL_VERSION 10
39
 
 
40
 
namespace po= boost::program_options;
41
33
using namespace std;
42
34
using namespace drizzled;
43
35
 
44
 
namespace drizzle_plugin
45
 
{
 
36
#define PROTOCOL_VERSION 10
46
37
 
47
 
std::vector<std::string> ClientMySQLProtocol::mysql_admin_ip_addresses;
48
38
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
 
 
57
 
static uint32_t random_seed1;
58
 
static uint32_t random_seed2;
59
 
static const uint32_t random_max= 0x3FFFFFFF;
60
 
static const double random_max_double= (double)0x3FFFFFFF;
61
 
 
62
 
 
63
 
ProtocolCounters *ListenMySQLProtocol::mysql_counters= new ProtocolCounters();
64
 
 
65
 
ListenMySQLProtocol::~ListenMySQLProtocol()
66
 
{ }
67
 
 
68
 
void ListenMySQLProtocol::addCountersToTable()
69
 
{
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));
73
 
}
74
 
 
75
 
const std::string ListenMySQLProtocol::getHost(void) const
76
 
{
77
 
  return _hostname;
 
39
static uint32_t port;
 
40
static uint32_t connect_timeout;
 
41
static uint32_t read_timeout;
 
42
static uint32_t write_timeout;
 
43
static uint32_t retry_count;
 
44
static uint32_t buffer_length;
 
45
static char* bind_address;
 
46
 
 
47
const char* ListenMySQLProtocol::getHost(void) const
 
48
{
 
49
  return bind_address;
78
50
}
79
51
 
80
52
in_port_t ListenMySQLProtocol::getPort(void) const
81
53
{
82
 
  return port.get();
 
54
  return (in_port_t) port;
83
55
}
84
56
 
85
57
plugin::Client *ListenMySQLProtocol::getClient(int fd)
89
61
  if (new_fd == -1)
90
62
    return NULL;
91
63
 
92
 
  return new ClientMySQLProtocol(new_fd, _using_mysql41_protocol, getCounters());
 
64
  return new (nothrow) ClientMySQLProtocol(new_fd, using_mysql41_protocol);
93
65
}
94
66
 
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)
 
67
ClientMySQLProtocol::ClientMySQLProtocol(int fd, bool using_mysql41_protocol_arg):
 
68
  using_mysql41_protocol(using_mysql41_protocol_arg)
99
69
{
100
 
  
101
70
  net.vio= 0;
102
71
 
103
72
  if (fd == -1)
104
73
    return;
105
74
 
106
 
  if (drizzleclient_net_init_sock(&net, fd, buffer_length.get()))
 
75
  if (drizzleclient_net_init_sock(&net, fd, 0, buffer_length))
107
76
    throw bad_alloc();
108
77
 
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();
 
78
  drizzleclient_net_set_read_timeout(&net, read_timeout);
 
79
  drizzleclient_net_set_write_timeout(&net, write_timeout);
 
80
  net.retry_count=retry_count;
112
81
}
113
82
 
114
83
ClientMySQLProtocol::~ClientMySQLProtocol()
115
84
{
116
85
  if (net.vio)
117
 
    net.vio->close();
 
86
    drizzleclient_vio_close(net.vio);
118
87
}
119
88
 
120
89
int ClientMySQLProtocol::getFileDescriptor(void)
153
122
  { 
154
123
    drizzleclient_net_close(&net);
155
124
    drizzleclient_net_end(&net);
156
 
    if (is_admin_connection)
157
 
      counters->adminConnected.decrement();
158
 
    else
159
 
      counters->connected.decrement();
160
125
  }
161
126
}
162
127
 
163
128
bool ClientMySQLProtocol::authenticate()
164
129
{
165
130
  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
 
  }
176
131
 
177
132
  /* 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());
 
133
  drizzleclient_net_set_read_timeout(&net, connect_timeout);
 
134
  drizzleclient_net_set_write_timeout(&net, connect_timeout);
180
135
 
181
136
  connection_is_valid= checkConnection();
182
137
 
183
138
  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
 
  }
 
139
    sendOK();
196
140
  else
197
141
  {
198
142
    sendError(session->main_da.sql_errno(), session->main_da.message());
199
 
    counters->failedConnections.increment();
200
143
    return false;
201
144
  }
202
145
 
203
146
  /* 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());
 
147
  drizzleclient_net_set_read_timeout(&net, read_timeout);
 
148
  drizzleclient_net_set_write_timeout(&net, write_timeout);
206
149
  return true;
207
150
}
208
151
 
228
171
  {
229
172
    /* Check if we can continue without closing the connection */
230
173
 
231
 
    if(net.last_errno== ER_NET_PACKET_TOO_LARGE)
 
174
    if(net.last_errno== CR_NET_PACKET_TOO_LARGE)
232
175
      my_error(ER_NET_PACKET_TOO_LARGE, MYF(0));
233
176
    if (session->main_da.status() == Diagnostics_area::DA_ERROR)
234
177
      sendError(session->main_da.sql_errno(), session->main_da.message());
239
182
      return false;                       // We have to close it.
240
183
 
241
184
    net.error= 0;
 
185
    *packet_length= 0;
 
186
    return true;
242
187
  }
243
188
 
244
189
  *l_packet= (char*) net.read_pos;
258
203
    (*l_packet)[0]= (unsigned char) COM_SLEEP;
259
204
    *packet_length= 1;
260
205
  }
261
 
  else if (_using_mysql41_protocol)
 
206
  else if (using_mysql41_protocol)
262
207
  {
263
208
    /* Map from MySQL commands to Drizzle commands. */
264
209
    switch ((int)(*l_packet)[0])
274
219
      break;
275
220
 
276
221
    case 14: /* PING */
277
 
      (*l_packet)[0]= (unsigned char) COM_PING;
 
222
      (*l_packet)[0]= (unsigned char) COM_SHUTDOWN;
278
223
      break;
279
224
 
280
225
 
281
226
    default:
282
 
      /* Respond with unknown command for MySQL commands we don't support. */
283
 
      (*l_packet)[0]= (unsigned char) COM_END;
 
227
      /* Just drop connection for MySQL commands we don't support. */
 
228
      (*l_packet)[0]= (unsigned char) COM_QUIT;
284
229
      *packet_length= 1;
285
230
      break;
286
231
    }
335
280
  if (session->main_da.status() == Diagnostics_area::DA_OK)
336
281
  {
337
282
    if (client_capabilities & CLIENT_FOUND_ROWS && session->main_da.found_rows())
338
 
      pos=storeLength(buff+1,session->main_da.found_rows());
 
283
      pos=drizzleclient_net_store_length(buff+1,session->main_da.found_rows());
339
284
    else
340
 
      pos=storeLength(buff+1,session->main_da.affected_rows());
341
 
    pos=storeLength(pos, session->main_da.last_insert_id());
 
285
      pos=drizzleclient_net_store_length(buff+1,session->main_da.affected_rows());
 
286
    pos=drizzleclient_net_store_length(pos, session->main_da.last_insert_id());
342
287
    int2store(pos, session->main_da.server_status());
343
288
    pos+=2;
344
289
    tmp= min(session->main_da.total_warn_count(), (uint32_t)65535);
346
291
  }
347
292
  else
348
293
  {
349
 
    pos=storeLength(buff+1,0);
350
 
    pos=storeLength(pos, 0);
 
294
    pos=drizzleclient_net_store_length(buff+1,0);
 
295
    pos=drizzleclient_net_store_length(pos, 0);
351
296
    int2store(pos, session->server_status);
352
297
    pos+=2;
353
298
    tmp= min(session->total_warn_count, (uint32_t)65535);
362
307
  if (message && message[0])
363
308
  {
364
309
    size_t length= strlen(message);
365
 
    pos=storeLength(pos,length);
 
310
    pos=drizzleclient_net_store_length(pos,length);
366
311
    memcpy(pos,(unsigned char*) message,length);
367
312
    pos+=length;
368
313
  }
398
343
    drizzleclient_net_flush(&net);
399
344
    session->main_da.can_overwrite_status= false;
400
345
  }
401
 
  packet.shrink(buffer_length.get());
 
346
  packet.shrink(buffer_length);
402
347
}
403
348
 
404
349
 
405
 
void ClientMySQLProtocol::sendError(drizzled::error_t sql_errno, const char *err)
 
350
void ClientMySQLProtocol::sendError(uint32_t sql_errno, const char *err)
406
351
{
407
352
  uint32_t length;
408
353
  /*
410
355
  */
411
356
  unsigned char buff[2+1+SQLSTATE_LENGTH+DRIZZLE_ERRMSG_SIZE], *pos;
412
357
 
413
 
  assert(sql_errno != EE_OK);
 
358
  assert(sql_errno);
414
359
  assert(err && err[0]);
415
360
 
416
361
  /*
435
380
    return;
436
381
  }
437
382
 
438
 
  int2store(buff, static_cast<uint16_t>(sql_errno));
 
383
  int2store(buff,sql_errno);
439
384
  pos= buff+2;
440
385
 
441
386
  /* The first # is to make the client backward compatible */
442
387
  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));
 
388
  pos= (unsigned char*) strcpy((char*) buff+3, drizzle_errno_to_sqlstate(sql_errno));
 
389
  pos+= strlen(drizzle_errno_to_sqlstate(sql_errno));
445
390
 
446
391
  char *tmp= strncpy((char*)pos, err, DRIZZLE_ERRMSG_SIZE-1);
447
392
  tmp+= strlen((char*)pos);
451
396
 
452
397
  drizzleclient_net_write_command(&net,(unsigned char) 255, (unsigned char*) "", 0, (unsigned char*) err, length);
453
398
 
454
 
  drizzleclient_net_flush(&net);
455
 
 
456
399
  session->main_da.can_overwrite_status= false;
457
400
}
458
401
 
481
424
  unsigned char buff[80];
482
425
  String tmp((char*) buff,sizeof(buff),&my_charset_bin);
483
426
 
484
 
  unsigned char *row_pos= storeLength(buff, list->elements);
 
427
  unsigned char *row_pos= drizzleclient_net_store_length(buff, list->elements);
485
428
  (void) drizzleclient_net_write(&net, buff, (size_t) (row_pos-buff));
486
429
 
487
430
  while ((item=it++))
508
451
    int2store(pos, field.charsetnr);
509
452
    int4store(pos+2, field.length);
510
453
 
511
 
    if (_using_mysql41_protocol)
 
454
    if (using_mysql41_protocol)
512
455
    {
513
456
      /* Switch to MySQL field numbering. */
514
457
      switch (field.type)
537
480
        pos[6]= 12;
538
481
        break;
539
482
 
540
 
      case DRIZZLE_TYPE_TIME:
541
 
        pos[6]= 13;
542
 
        break;
543
 
 
544
483
      case DRIZZLE_TYPE_DATE:
545
484
        pos[6]= 14;
546
485
        break;
549
488
        pos[6]= 15;
550
489
        break;
551
490
 
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
491
      case DRIZZLE_TYPE_DECIMAL:
565
492
        pos[6]= (char)246;
566
493
        break;
612
539
  char buff[MAX_FIELD_WIDTH];
613
540
  String str(buff,sizeof(buff), &my_charset_bin);
614
541
 
615
 
  from->val_str_internal(&str);
 
542
  from->val_str(&str);
616
543
 
617
544
  return netStoreData((const unsigned char *)str.ptr(), str.length());
618
545
}
628
555
{
629
556
  char buff[12];
630
557
  return netStoreData((unsigned char*) buff,
631
 
                      (size_t) (internal::int10_to_str(from, buff, -10) - buff));
 
558
                      (size_t) (int10_to_str(from, buff, -10) - buff));
632
559
}
633
560
 
634
561
bool ClientMySQLProtocol::store(uint32_t from)
635
562
{
636
563
  char buff[11];
637
564
  return netStoreData((unsigned char*) buff,
638
 
                      (size_t) (internal::int10_to_str(from, buff, 10) - buff));
 
565
                      (size_t) (int10_to_str(from, buff, 10) - buff));
639
566
}
640
567
 
641
568
bool ClientMySQLProtocol::store(int64_t from)
642
569
{
643
570
  char buff[22];
644
571
  return netStoreData((unsigned char*) buff,
645
 
                      (size_t) (internal::int64_t10_to_str(from, buff, -10) - buff));
 
572
                      (size_t) (int64_t10_to_str(from, buff, -10) - buff));
646
573
}
647
574
 
648
575
bool ClientMySQLProtocol::store(uint64_t from)
649
576
{
650
577
  char buff[21];
651
578
  return netStoreData((unsigned char*) buff,
652
 
                      (size_t) (internal::int64_t10_to_str(from, buff, 10) - buff));
 
579
                      (size_t) (int64_t10_to_str(from, buff, 10) - buff));
653
580
}
654
581
 
655
582
bool ClientMySQLProtocol::store(double from, uint32_t decimals, String *buffer)
682
609
{
683
610
  uint32_t pkt_len= 0;
684
611
  char *end;
685
 
  char scramble[SCRAMBLE_LENGTH];
686
 
  identifier::User::shared_ptr user_identifier= identifier::User::make_shared();
687
 
 
688
 
  makeScramble(scramble);
689
612
 
690
613
  // TCP/IP connection
691
614
  {
694
617
 
695
618
    if (drizzleclient_net_peer_addr(&net, ip, &peer_port, NI_MAXHOST))
696
619
    {
697
 
      my_error(ER_BAD_HOST_ERROR, MYF(0), ip);
 
620
      my_error(ER_BAD_HOST_ERROR, MYF(0), session->security_ctx.ip.c_str());
698
621
      return false;
699
622
    }
700
623
 
701
 
    user_identifier->setAddress(ip);
 
624
    session->security_ctx.ip.assign(ip);
702
625
  }
703
626
  drizzleclient_net_keepalive(&net, true);
704
627
 
709
632
 
710
633
    server_capabilites= CLIENT_BASIC_FLAGS;
711
634
 
712
 
    if (_using_mysql41_protocol)
 
635
    if (using_mysql41_protocol)
713
636
      server_capabilites|= CLIENT_PROTOCOL_MYSQL41;
714
637
 
715
638
#ifdef HAVE_COMPRESS
716
639
    server_capabilites|= CLIENT_COMPRESS;
717
640
#endif /* HAVE_COMPRESS */
718
641
 
719
 
    end= buff + strlen(PANDORA_RELEASE_VERSION);
 
642
    end= buff + strlen(VERSION);
720
643
    if ((end - buff) >= SERVER_VERSION_LENGTH)
721
644
      end= buff + (SERVER_VERSION_LENGTH - 1);
722
 
    memcpy(buff, PANDORA_RELEASE_VERSION, end - buff);
 
645
    memcpy(buff, VERSION, end - buff);
723
646
    *end= 0;
724
647
    end++;
725
648
 
726
 
    int4store((unsigned char*) end, session->variables.pseudo_thread_id);
 
649
    int4store((unsigned char*) end, global_thread_id);
727
650
    end+= 4;
728
651
 
729
652
    /* We don't use scramble anymore. */
730
 
    memcpy(end, scramble, SCRAMBLE_LENGTH_323);
 
653
    memset(end, 'X', SCRAMBLE_LENGTH_323);
731
654
    end+= SCRAMBLE_LENGTH_323;
732
655
    *end++= 0; /* an empty byte for some reason */
733
656
 
739
662
    end+= 18;
740
663
 
741
664
    /* Write scramble tail. */
742
 
    memcpy(end, scramble + SCRAMBLE_LENGTH_323, SCRAMBLE_LENGTH - SCRAMBLE_LENGTH_323);
 
665
    memset(end, 'X', SCRAMBLE_LENGTH - SCRAMBLE_LENGTH_323);
743
666
    end+= (SCRAMBLE_LENGTH - SCRAMBLE_LENGTH_323);
744
667
    *end++= 0; /* an empty byte for some reason */
745
668
 
753
676
        ||    (pkt_len= drizzleclient_net_read(&net)) == packet_error 
754
677
        || pkt_len < MIN_HANDSHAKE_SIZE)
755
678
    {
756
 
      my_error(ER_HANDSHAKE_ERROR, MYF(0), user_identifier->address().c_str());
 
679
      my_error(ER_HANDSHAKE_ERROR, MYF(0), session->security_ctx.ip.c_str());
757
680
      return false;
758
681
    }
759
682
  }
760
 
  if (packet.alloc(buffer_length.get()))
 
683
  if (packet.alloc(buffer_length))
761
684
    return false; /* The error is set by alloc(). */
762
685
 
763
686
  client_capabilities= uint2korr(net.read_pos);
764
 
  if (!(client_capabilities & CLIENT_PROTOCOL_MYSQL41))
765
 
  {
766
 
    my_error(ER_HANDSHAKE_ERROR, MYF(0), user_identifier->address().c_str());
767
 
    return false;
768
 
  }
 
687
 
769
688
 
770
689
  client_capabilities|= ((uint32_t) uint2korr(net.read_pos + 2)) << 16;
771
690
  session->max_client_packet_length= uint4korr(net.read_pos + 4);
779
698
 
780
699
  if (end >= (char*) net.read_pos + pkt_len + 2)
781
700
  {
782
 
    my_error(ER_HANDSHAKE_ERROR, MYF(0), user_identifier->address().c_str());
 
701
    my_error(ER_HANDSHAKE_ERROR, MYF(0), session->security_ctx.ip.c_str());
783
702
    return false;
784
703
  }
785
704
 
791
710
  char *l_db= passwd;
792
711
 
793
712
  /*
794
 
    Only support new password format.
 
713
    Old clients send null-terminated string as password; new clients send
 
714
    the size (1 byte) + string (not null-terminated). Hence in case of empty
 
715
    password both send '\0'.
 
716
 
 
717
    This strlen() can't be easily deleted without changing client.
795
718
 
796
719
    Cast *passwd to an unsigned char, so that it doesn't extend the sign for
797
720
    *passwd > 127 and become 2**32-127+ after casting to uint.
798
721
  */
799
 
  uint32_t passwd_len;
800
 
  if (client_capabilities & CLIENT_SECURE_CONNECTION &&
801
 
      passwd < (char *) net.read_pos + pkt_len)
802
 
  {
803
 
    passwd_len= (unsigned char)(*passwd++);
804
 
    if (passwd_len > 0)
805
 
    {
806
 
      user_identifier->setPasswordType(identifier::User::MYSQL_HASH);
807
 
      user_identifier->setPasswordContext(scramble, SCRAMBLE_LENGTH);
808
 
    }
809
 
  }
810
 
  else
811
 
  {
812
 
    passwd_len= 0;
813
 
  }
814
 
 
815
 
  if (client_capabilities & CLIENT_CONNECT_WITH_DB &&
816
 
      passwd < (char *) net.read_pos + pkt_len)
817
 
  {
818
 
    l_db= l_db + passwd_len + 1;
819
 
  }
820
 
  else
821
 
  {
822
 
    l_db= NULL;
823
 
  }
 
722
  uint32_t passwd_len= client_capabilities & CLIENT_SECURE_CONNECTION ?
 
723
    (unsigned char)(*passwd++) : strlen(passwd);
 
724
  l_db= client_capabilities & CLIENT_CONNECT_WITH_DB ? l_db + passwd_len + 1 : 0;
824
725
 
825
726
  /* strlen() can't be easily deleted without changing client */
826
727
  uint32_t db_len= l_db ? strlen(l_db) : 0;
827
728
 
828
729
  if (passwd + passwd_len + db_len > (char *) net.read_pos + pkt_len)
829
730
  {
830
 
    my_error(ER_HANDSHAKE_ERROR, MYF(0), user_identifier->address().c_str());
 
731
    my_error(ER_HANDSHAKE_ERROR, MYF(0), session->security_ctx.ip.c_str());
831
732
    return false;
832
733
  }
833
734
 
839
740
    user_len-= 2;
840
741
  }
841
742
 
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);
857
 
 
858
 
  return session->checkUser(string(passwd, passwd_len),
859
 
                            string(l_db ? l_db : ""));
860
 
 
861
 
}
862
 
 
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;
 
743
  session->security_ctx.user.assign(user);
 
744
 
 
745
  return session->checkUser(passwd, passwd_len, l_db);
869
746
}
870
747
 
871
748
bool ClientMySQLProtocol::netStoreData(const unsigned char *from, size_t length)
873
750
  size_t packet_length= packet.length();
874
751
  /*
875
752
     The +9 comes from that strings of length longer than 16M require
876
 
     9 bytes to be stored (see storeLength).
 
753
     9 bytes to be stored (see drizzleclient_net_store_length).
877
754
  */
878
755
  if (packet_length+9+length > packet.alloced_length() &&
879
756
      packet.realloc(packet_length+9+length))
880
757
    return 1;
881
 
  unsigned char *to= storeLength((unsigned char*) packet.ptr()+packet_length, length);
 
758
  unsigned char *to= drizzleclient_net_store_length((unsigned char*) packet.ptr()+packet_length, length);
882
759
  memcpy(to,from,length);
883
760
  packet.length((size_t) (to+length-(unsigned char*) packet.ptr()));
884
761
  return 0;
911
788
  drizzleclient_net_write(&net, buff, 5);
912
789
}
913
790
 
914
 
/*
915
 
  Store an integer with simple packing into a output package
916
 
 
917
 
  buffer      Store the packed integer here
918
 
  length    integers to store
919
 
 
920
 
  This is mostly used to store lengths of strings.  We have to cast
921
 
  the result for the LL() becasue of a bug in Forte CC compiler.
922
 
 
923
 
  RETURN
924
 
  Position in 'buffer' after the packed length
925
 
*/
926
 
 
927
 
unsigned char *ClientMySQLProtocol::storeLength(unsigned char *buffer, uint64_t length)
928
 
{
929
 
  if (length < (uint64_t) 251LL)
930
 
  {
931
 
    *buffer=(unsigned char) length;
932
 
    return buffer+1;
933
 
  }
934
 
  /* 251 is reserved for NULL */
935
 
  if (length < (uint64_t) 65536LL)
936
 
  {
937
 
    *buffer++=252;
938
 
    int2store(buffer,(uint32_t) length);
939
 
    return buffer+2;
940
 
  }
941
 
  if (length < (uint64_t) 16777216LL)
942
 
  {
943
 
    *buffer++=253;
944
 
    int3store(buffer,(uint32_t) length);
945
 
    return buffer+3;
946
 
  }
947
 
  *buffer++=254;
948
 
  int8store(buffer,length);
949
 
  return buffer+8;
950
 
}
951
 
 
952
 
void ClientMySQLProtocol::makeScramble(char *scramble)
953
 
{
954
 
  /* This is the MySQL algorithm with minimal changes. */
955
 
  random_seed1= (random_seed1 * 3 + random_seed2) % random_max;
956
 
  random_seed2= (random_seed1 + random_seed2 + 33) % random_max;
957
 
  uint32_t seed= static_cast<uint32_t>((static_cast<double>(random_seed1) / random_max_double) * 0xffffffff);
958
 
 
959
 
  void *pointer= this;
960
 
  uint32_t pointer_seed;
961
 
  memcpy(&pointer_seed, &pointer, 4);
962
 
  uint32_t random1= (seed + pointer_seed) % random_max;
963
 
  uint32_t random2= (seed + session->variables.pseudo_thread_id + net.vio->get_fd()) % random_max;
964
 
 
965
 
  for (char *end= scramble + SCRAMBLE_LENGTH; scramble != end; scramble++)
966
 
  {
967
 
    random1= (random1 * 3 + random2) % random_max;
968
 
    random2= (random1 + random2 + 33) % random_max;
969
 
    *scramble= static_cast<char>((static_cast<double>(random1) / random_max_double) * 94 + 33);
970
 
  }
971
 
}
972
 
 
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
791
static ListenMySQLProtocol *listen_obj= NULL;
984
 
plugin::Create_function<MySQLPassword> *mysql_password= NULL;
985
 
 
986
 
static int init(drizzled::module::Context &context)
987
 
{  
988
 
  /* Initialize random seeds for the MySQL algorithm with minimal changes. */
989
 
  time_t seed_time= time(NULL);
990
 
  random_seed1= seed_time % random_max;
991
 
  random_seed2= (seed_time / 2) % random_max;
992
 
 
993
 
  const module::option_map &vm= context.getOptions();
994
 
 
995
 
  mysql_password= new plugin::Create_function<MySQLPassword>(MySQLPasswordName);
996
 
  context.add(mysql_password);
997
 
 
998
 
  listen_obj= new ListenMySQLProtocol("mysql_protocol", vm["bind-address"].as<std::string>(), true);
999
 
  listen_obj->addCountersToTable();
1000
 
  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
 
 
1012
 
  return 0;
1013
 
}
1014
 
 
1015
 
static void init_options(drizzled::module::option_context &context)
1016
 
{
1017
 
  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 "
1020
 
                              "protocol."));
1021
 
  context("connect-timeout",
1022
 
          po::value<timeout_constraint>(&connect_timeout)->default_value(10),
1023
 
          _("Connect Timeout."));
1024
 
  context("read-timeout",
1025
 
          po::value<timeout_constraint>(&read_timeout)->default_value(30),
1026
 
          _("Read Timeout."));
1027
 
  context("write-timeout",
1028
 
          po::value<timeout_constraint>(&write_timeout)->default_value(60),
1029
 
          _("Write Timeout."));
1030
 
  context("retry-count",
1031
 
          po::value<retry_constraint>(&retry_count)->default_value(10),
1032
 
          _("Retry Count."));
1033
 
  context("buffer-length",
1034
 
          po::value<buffer_constraint>(&buffer_length)->default_value(16384),
1035
 
          _("Buffer length."));
1036
 
  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 */
 
792
 
 
793
static int init(drizzled::plugin::Registry &registry)
 
794
{
 
795
  listen_obj= new ListenMySQLProtocol("mysql_protocol", true);
 
796
  registry.add(listen_obj); 
 
797
  return 0;
 
798
}
 
799
 
 
800
static int deinit(drizzled::plugin::Registry &registry)
 
801
{
 
802
  registry.remove(listen_obj);
 
803
  delete listen_obj;
 
804
  return 0;
 
805
}
 
806
 
 
807
static DRIZZLE_SYSVAR_UINT(port, port, PLUGIN_VAR_RQCMDARG,
 
808
                           N_("Port number to use for connection or 0 for default to with MySQL "
 
809
                              "protocol."),
 
810
                           NULL, NULL, 3306, 0, 65535, 0);
 
811
static DRIZZLE_SYSVAR_UINT(connect_timeout, connect_timeout,
 
812
                           PLUGIN_VAR_RQCMDARG, N_("Connect Timeout."),
 
813
                           NULL, NULL, 10, 1, 300, 0);
 
814
static DRIZZLE_SYSVAR_UINT(read_timeout, read_timeout, PLUGIN_VAR_RQCMDARG,
 
815
                           N_("Read Timeout."), NULL, NULL, 30, 1, 300, 0);
 
816
static DRIZZLE_SYSVAR_UINT(write_timeout, write_timeout, PLUGIN_VAR_RQCMDARG,
 
817
                           N_("Write Timeout."), NULL, NULL, 60, 1, 300, 0);
 
818
static DRIZZLE_SYSVAR_UINT(retry_count, retry_count, PLUGIN_VAR_RQCMDARG,
 
819
                           N_("Retry Count."), NULL, NULL, 10, 1, 100, 0);
 
820
static DRIZZLE_SYSVAR_UINT(buffer_length, buffer_length, PLUGIN_VAR_RQCMDARG,
 
821
                           N_("Buffer length."), NULL, NULL, 16384, 1024,
 
822
                           1024*1024, 0);
 
823
static DRIZZLE_SYSVAR_STR(bind_address, bind_address, PLUGIN_VAR_READONLY,
 
824
                          N_("Address to bind to."), NULL, NULL, NULL);
 
825
 
 
826
static drizzle_sys_var* system_variables[]= {
 
827
  DRIZZLE_SYSVAR(port),
 
828
  DRIZZLE_SYSVAR(connect_timeout),
 
829
  DRIZZLE_SYSVAR(read_timeout),
 
830
  DRIZZLE_SYSVAR(write_timeout),
 
831
  DRIZZLE_SYSVAR(retry_count),
 
832
  DRIZZLE_SYSVAR(buffer_length),
 
833
  DRIZZLE_SYSVAR(bind_address),
 
834
  NULL
 
835
};
1048
836
 
1049
837
DRIZZLE_DECLARE_PLUGIN
1050
838
{
1051
 
  DRIZZLE_VERSION_ID,
1052
 
  "mysql-protocol",
 
839
  "mysql_protocol",
1053
840
  "0.1",
1054
841
  "Eric Day",
1055
842
  "MySQL Protocol Module",
1056
843
  PLUGIN_LICENSE_GPL,
1057
 
  drizzle_plugin::init,             /* Plugin Init */
1058
 
  NULL, /* depends */
1059
 
  drizzle_plugin::init_options    /* config options */
 
844
  init,             /* Plugin Init */
 
845
  deinit,           /* Plugin Deinit */
 
846
  NULL,             /* status variables */
 
847
  system_variables, /* system variables */
 
848
  NULL              /* config options */
1060
849
}
1061
850
DRIZZLE_DECLARE_PLUGIN_END;