← 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: Brian Aker
  • Date: 2010-04-05 23:46:43 UTC
  • Revision ID: brian@gaz-20100405234643-0he3xnj902rc70r8
Fixing tests to work with PBXT.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/mysql_protocol/mysql_protocol.cc
 
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
3
 *
 
4
 *  Copyright (C) 2008 Sun Microsystems
 
5
 *
 
6
 * This program is free software; you can redistribute it and/or modify
 
7
 * it under the terms of the GNU General Public License as published by
 
8
 * the Free Software Foundation; version 2 of the License.
 
9
 *
 
10
 * This program is distributed in the hope that it will be useful,
 
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 * GNU General Public License for more details.
 
14
 *
 
15
 * You should have received a copy of the GNU General Public License
 
16
 * along with this program; if not, write to the Free Software
 
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
18
 */
 
19
 
 
20
#include "config.h"
 
21
#include <drizzled/gettext.h>
 
22
#include <drizzled/error.h>
 
23
#include <drizzled/query_id.h>
 
24
#include <drizzled/sql_state.h>
 
25
#include <drizzled/session.h>
 
26
#include "drizzled/internal/m_string.h"
 
27
#include <algorithm>
 
28
 
 
29
#include "errmsg.h"
 
30
#include "mysql_protocol.h"
 
31
#include "mysql_password.h"
 
32
#include "options.h"
 
33
 
 
34
using namespace std;
 
35
using namespace drizzled;
 
36
 
 
37
#define PROTOCOL_VERSION 10
 
38
 
 
39
namespace drizzled
 
40
{
 
41
extern uint32_t global_thread_id;
 
42
}
 
43
 
 
44
static const unsigned int PACKET_BUFFER_EXTRA_ALLOC= 1024;
 
45
static uint32_t port;
 
46
static uint32_t connect_timeout;
 
47
static uint32_t read_timeout;
 
48
static uint32_t write_timeout;
 
49
static uint32_t retry_count;
 
50
static uint32_t buffer_length;
 
51
static char* bind_address;
 
52
static uint32_t random_seed1;
 
53
static uint32_t random_seed2;
 
54
static const uint32_t random_max= 0x3FFFFFFF;
 
55
static const double random_max_double= (double)0x3FFFFFFF;
 
56
 
 
57
const char* ListenMySQLProtocol::getHost(void) const
 
58
{
 
59
  return bind_address;
 
60
}
 
61
 
 
62
in_port_t ListenMySQLProtocol::getPort(void) const
 
63
{
 
64
  return (in_port_t) port;
 
65
}
 
66
 
 
67
plugin::Client *ListenMySQLProtocol::getClient(int fd)
 
68
{
 
69
  int new_fd;
 
70
  new_fd= acceptTcp(fd);
 
71
  if (new_fd == -1)
 
72
    return NULL;
 
73
 
 
74
  return new (nothrow) ClientMySQLProtocol(new_fd, using_mysql41_protocol);
 
75
}
 
76
 
 
77
ClientMySQLProtocol::ClientMySQLProtocol(int fd, bool using_mysql41_protocol_arg):
 
78
  using_mysql41_protocol(using_mysql41_protocol_arg)
 
79
{
 
80
  net.vio= 0;
 
81
 
 
82
  if (fd == -1)
 
83
    return;
 
84
 
 
85
  if (drizzleclient_net_init_sock(&net, fd, buffer_length))
 
86
    throw bad_alloc();
 
87
 
 
88
  drizzleclient_net_set_read_timeout(&net, read_timeout);
 
89
  drizzleclient_net_set_write_timeout(&net, write_timeout);
 
90
  net.retry_count=retry_count;
 
91
}
 
92
 
 
93
ClientMySQLProtocol::~ClientMySQLProtocol()
 
94
{
 
95
  if (net.vio)
 
96
    vio_close(net.vio);
 
97
}
 
98
 
 
99
int ClientMySQLProtocol::getFileDescriptor(void)
 
100
{
 
101
  return drizzleclient_net_get_sd(&net);
 
102
}
 
103
 
 
104
bool ClientMySQLProtocol::isConnected()
 
105
{
 
106
  return net.vio != 0;
 
107
}
 
108
 
 
109
bool ClientMySQLProtocol::isReading(void)
 
110
{
 
111
  return net.reading_or_writing == 1;
 
112
}
 
113
 
 
114
bool ClientMySQLProtocol::isWriting(void)
 
115
{
 
116
  return net.reading_or_writing == 2;
 
117
}
 
118
 
 
119
bool ClientMySQLProtocol::flush()
 
120
{
 
121
  if (net.vio == NULL)
 
122
    return false;
 
123
  bool ret= drizzleclient_net_write(&net, (unsigned char*) packet.ptr(),
 
124
                           packet.length());
 
125
  packet.length(0);
 
126
  return ret;
 
127
}
 
128
 
 
129
void ClientMySQLProtocol::close(void)
 
130
{
 
131
  if (net.vio)
 
132
  { 
 
133
    drizzleclient_net_close(&net);
 
134
    drizzleclient_net_end(&net);
 
135
  }
 
136
}
 
137
 
 
138
bool ClientMySQLProtocol::authenticate()
 
139
{
 
140
  bool connection_is_valid;
 
141
 
 
142
  /* Use "connect_timeout" value during connection phase */
 
143
  drizzleclient_net_set_read_timeout(&net, connect_timeout);
 
144
  drizzleclient_net_set_write_timeout(&net, connect_timeout);
 
145
 
 
146
  connection_is_valid= checkConnection();
 
147
 
 
148
  if (connection_is_valid)
 
149
    sendOK();
 
150
  else
 
151
  {
 
152
    sendError(session->main_da.sql_errno(), session->main_da.message());
 
153
    return false;
 
154
  }
 
155
 
 
156
  /* Connect completed, set read/write timeouts back to default */
 
157
  drizzleclient_net_set_read_timeout(&net, read_timeout);
 
158
  drizzleclient_net_set_write_timeout(&net, write_timeout);
 
159
  return true;
 
160
}
 
161
 
 
162
bool ClientMySQLProtocol::readCommand(char **l_packet, uint32_t *packet_length)
 
163
{
 
164
  /*
 
165
    This thread will do a blocking read from the client which
 
166
    will be interrupted when the next command is received from
 
167
    the client, the connection is closed or "net_wait_timeout"
 
168
    number of seconds has passed
 
169
  */
 
170
#ifdef NEVER
 
171
  /* We can do this much more efficiently with poll timeouts or watcher thread,
 
172
     disabling for now, which means net_wait_timeout == read_timeout. */
 
173
  drizzleclient_net_set_read_timeout(&net,
 
174
                                     session->variables.net_wait_timeout);
 
175
#endif
 
176
 
 
177
  net.pkt_nr=0;
 
178
 
 
179
  *packet_length= drizzleclient_net_read(&net);
 
180
  if (*packet_length == packet_error)
 
181
  {
 
182
    /* Check if we can continue without closing the connection */
 
183
 
 
184
    if(net.last_errno== ER_NET_PACKET_TOO_LARGE)
 
185
      my_error(ER_NET_PACKET_TOO_LARGE, MYF(0));
 
186
    if (session->main_da.status() == Diagnostics_area::DA_ERROR)
 
187
      sendError(session->main_da.sql_errno(), session->main_da.message());
 
188
    else
 
189
      sendOK();
 
190
 
 
191
    if (net.error != 3)
 
192
      return false;                       // We have to close it.
 
193
 
 
194
    net.error= 0;
 
195
    *packet_length= 0;
 
196
    return true;
 
197
  }
 
198
 
 
199
  *l_packet= (char*) net.read_pos;
 
200
 
 
201
  /*
 
202
    'packet_length' contains length of data, as it was stored in packet
 
203
    header. In case of malformed header, drizzleclient_net_read returns zero.
 
204
    If packet_length is not zero, drizzleclient_net_read ensures that the returned
 
205
    number of bytes was actually read from network.
 
206
    There is also an extra safety measure in drizzleclient_net_read:
 
207
    it sets packet[packet_length]= 0, but only for non-zero packets.
 
208
  */
 
209
 
 
210
  if (*packet_length == 0)                       /* safety */
 
211
  {
 
212
    /* Initialize with COM_SLEEP packet */
 
213
    (*l_packet)[0]= (unsigned char) COM_SLEEP;
 
214
    *packet_length= 1;
 
215
  }
 
216
  else if (using_mysql41_protocol)
 
217
  {
 
218
    /* Map from MySQL commands to Drizzle commands. */
 
219
    switch ((int)(*l_packet)[0])
 
220
    {
 
221
    case 0: /* SLEEP */
 
222
    case 1: /* QUIT */
 
223
    case 2: /* INIT_DB */
 
224
    case 3: /* QUERY */
 
225
      break;
 
226
 
 
227
    case 8: /* SHUTDOWN */
 
228
      (*l_packet)[0]= (unsigned char) COM_SHUTDOWN;
 
229
      break;
 
230
 
 
231
    case 14: /* PING */
 
232
      (*l_packet)[0]= (unsigned char) COM_PING;
 
233
      break;
 
234
 
 
235
 
 
236
    default:
 
237
      /* Respond with unknown command for MySQL commands we don't support. */
 
238
      (*l_packet)[0]= (unsigned char) COM_END;
 
239
      *packet_length= 1;
 
240
      break;
 
241
    }
 
242
  }
 
243
 
 
244
  /* Do not rely on drizzleclient_net_read, extra safety against programming errors. */
 
245
  (*l_packet)[*packet_length]= '\0';                  /* safety */
 
246
 
 
247
#ifdef NEVER
 
248
  /* See comment above. */
 
249
  /* Restore read timeout value */
 
250
  drizzleclient_net_set_read_timeout(&net,
 
251
                                     session->variables.net_read_timeout);
 
252
#endif
 
253
 
 
254
  return true;
 
255
}
 
256
 
 
257
/**
 
258
  Return ok to the client.
 
259
 
 
260
  The ok packet has the following structure:
 
261
 
 
262
  - 0               : Marker (1 byte)
 
263
  - affected_rows    : Stored in 1-9 bytes
 
264
  - id        : Stored in 1-9 bytes
 
265
  - server_status    : Copy of session->server_status;  Can be used by client
 
266
  to check if we are inside an transaction.
 
267
  New in 4.0 client
 
268
  - warning_count    : Stored in 2 bytes; New in 4.1 client
 
269
  - message        : Stored as packed length (1-9 bytes) + message.
 
270
  Is not stored if no message.
 
271
 
 
272
  @param session           Thread handler
 
273
  @param affected_rows       Number of rows changed by statement
 
274
  @param id           Auto_increment id for first row (if used)
 
275
  @param message       Message to send to the client (Used by mysql_status)
 
276
*/
 
277
 
 
278
void ClientMySQLProtocol::sendOK()
 
279
{
 
280
  unsigned char buff[DRIZZLE_ERRMSG_SIZE+10],*pos;
 
281
  const char *message= NULL;
 
282
  uint32_t tmp;
 
283
 
 
284
  if (!net.vio)    // hack for re-parsing queries
 
285
  {
 
286
    return;
 
287
  }
 
288
 
 
289
  buff[0]=0;                    // No fields
 
290
  if (session->main_da.status() == Diagnostics_area::DA_OK)
 
291
  {
 
292
    if (client_capabilities & CLIENT_FOUND_ROWS && session->main_da.found_rows())
 
293
      pos=storeLength(buff+1,session->main_da.found_rows());
 
294
    else
 
295
      pos=storeLength(buff+1,session->main_da.affected_rows());
 
296
    pos=storeLength(pos, session->main_da.last_insert_id());
 
297
    int2store(pos, session->main_da.server_status());
 
298
    pos+=2;
 
299
    tmp= min(session->main_da.total_warn_count(), (uint32_t)65535);
 
300
    message= session->main_da.message();
 
301
  }
 
302
  else
 
303
  {
 
304
    pos=storeLength(buff+1,0);
 
305
    pos=storeLength(pos, 0);
 
306
    int2store(pos, session->server_status);
 
307
    pos+=2;
 
308
    tmp= min(session->total_warn_count, (uint32_t)65535);
 
309
  }
 
310
 
 
311
  /* We can only return up to 65535 warnings in two bytes */
 
312
  int2store(pos, tmp);
 
313
  pos+= 2;
 
314
 
 
315
  session->main_da.can_overwrite_status= true;
 
316
 
 
317
  if (message && message[0])
 
318
  {
 
319
    size_t length= strlen(message);
 
320
    pos=storeLength(pos,length);
 
321
    memcpy(pos,(unsigned char*) message,length);
 
322
    pos+=length;
 
323
  }
 
324
  drizzleclient_net_write(&net, buff, (size_t) (pos-buff));
 
325
  drizzleclient_net_flush(&net);
 
326
 
 
327
  session->main_da.can_overwrite_status= false;
 
328
}
 
329
 
 
330
/**
 
331
  Send eof (= end of result set) to the client.
 
332
 
 
333
  The eof packet has the following structure:
 
334
 
 
335
  - 254    (DRIZZLE_PROTOCOL_NO_MORE_DATA)    : Marker (1 byte)
 
336
  - warning_count    : Stored in 2 bytes; New in 4.1 client
 
337
  - status_flag    : Stored in 2 bytes;
 
338
  For flags like SERVER_MORE_RESULTS_EXISTS.
 
339
 
 
340
  Note that the warning count will not be sent if 'no_flush' is set as
 
341
  we don't want to report the warning count until all data is sent to the
 
342
  client.
 
343
*/
 
344
 
 
345
void ClientMySQLProtocol::sendEOF()
 
346
{
 
347
  /* Set to true if no active vio, to work well in case of --init-file */
 
348
  if (net.vio != 0)
 
349
  {
 
350
    session->main_da.can_overwrite_status= true;
 
351
    writeEOFPacket(session->main_da.server_status(),
 
352
                   session->main_da.total_warn_count());
 
353
    drizzleclient_net_flush(&net);
 
354
    session->main_da.can_overwrite_status= false;
 
355
  }
 
356
  packet.shrink(buffer_length);
 
357
}
 
358
 
 
359
 
 
360
void ClientMySQLProtocol::sendError(uint32_t sql_errno, const char *err)
 
361
{
 
362
  uint32_t length;
 
363
  /*
 
364
    buff[]: sql_errno:2 + ('#':1 + SQLSTATE_LENGTH:5) + DRIZZLE_ERRMSG_SIZE:512
 
365
  */
 
366
  unsigned char buff[2+1+SQLSTATE_LENGTH+DRIZZLE_ERRMSG_SIZE], *pos;
 
367
 
 
368
  assert(sql_errno);
 
369
  assert(err && err[0]);
 
370
 
 
371
  /*
 
372
    It's one case when we can push an error even though there
 
373
    is an OK or EOF already.
 
374
  */
 
375
  session->main_da.can_overwrite_status= true;
 
376
 
 
377
  /* Abort multi-result sets */
 
378
  session->server_status&= ~SERVER_MORE_RESULTS_EXISTS;
 
379
 
 
380
  /**
 
381
    Send a error string to client.
 
382
 
 
383
    For SIGNAL/RESIGNAL and GET DIAGNOSTICS functionality it's
 
384
    critical that every error that can be intercepted is issued in one
 
385
    place only, my_message_sql.
 
386
  */
 
387
 
 
388
  if (net.vio == 0)
 
389
  {
 
390
    return;
 
391
  }
 
392
 
 
393
  int2store(buff,sql_errno);
 
394
  pos= buff+2;
 
395
 
 
396
  /* The first # is to make the client backward compatible */
 
397
  buff[2]= '#';
 
398
  pos= (unsigned char*) strcpy((char*) buff+3, drizzle_errno_to_sqlstate(sql_errno));
 
399
  pos+= strlen(drizzle_errno_to_sqlstate(sql_errno));
 
400
 
 
401
  char *tmp= strncpy((char*)pos, err, DRIZZLE_ERRMSG_SIZE-1);
 
402
  tmp+= strlen((char*)pos);
 
403
  tmp[0]= '\0';
 
404
  length= (uint32_t)(tmp-(char*)buff);
 
405
  err= (char*) buff;
 
406
 
 
407
  drizzleclient_net_write_command(&net,(unsigned char) 255, (unsigned char*) "", 0, (unsigned char*) err, length);
 
408
 
 
409
  session->main_da.can_overwrite_status= false;
 
410
}
 
411
 
 
412
/**
 
413
  Send name and type of result to client.
 
414
 
 
415
  Sum fields has table name empty and field_name.
 
416
 
 
417
  @param Session        Thread data object
 
418
  @param list            List of items to send to client
 
419
  @param flag            Bit mask with the following functions:
 
420
                        - 1 send number of rows
 
421
                        - 2 send default values
 
422
                        - 4 don't write eof packet
 
423
 
 
424
  @retval
 
425
    0    ok
 
426
  @retval
 
427
    1    Error  (Note that in this case the error is not sent to the
 
428
    client)
 
429
*/
 
430
bool ClientMySQLProtocol::sendFields(List<Item> *list)
 
431
{
 
432
  List_iterator_fast<Item> it(*list);
 
433
  Item *item;
 
434
  unsigned char buff[80];
 
435
  String tmp((char*) buff,sizeof(buff),&my_charset_bin);
 
436
 
 
437
  unsigned char *row_pos= storeLength(buff, list->elements);
 
438
  (void) drizzleclient_net_write(&net, buff, (size_t) (row_pos-buff));
 
439
 
 
440
  while ((item=it++))
 
441
  {
 
442
    char *pos;
 
443
    SendField field;
 
444
    item->make_field(&field);
 
445
 
 
446
    packet.length(0);
 
447
 
 
448
    if (store(STRING_WITH_LEN("def")) ||
 
449
        store(field.db_name) ||
 
450
        store(field.table_name) ||
 
451
        store(field.org_table_name) ||
 
452
        store(field.col_name) ||
 
453
        store(field.org_col_name) ||
 
454
        packet.realloc(packet.length()+12))
 
455
      goto err;
 
456
 
 
457
    /* Store fixed length fields */
 
458
    pos= (char*) packet.ptr()+packet.length();
 
459
    *pos++= 12;                // Length of packed fields
 
460
    /* No conversion */
 
461
    int2store(pos, field.charsetnr);
 
462
    int4store(pos+2, field.length);
 
463
 
 
464
    if (using_mysql41_protocol)
 
465
    {
 
466
      /* Switch to MySQL field numbering. */
 
467
      switch (field.type)
 
468
      {
 
469
      case DRIZZLE_TYPE_LONG:
 
470
        pos[6]= 3;
 
471
        break;
 
472
 
 
473
      case DRIZZLE_TYPE_DOUBLE:
 
474
        pos[6]= 5;
 
475
        break;
 
476
 
 
477
      case DRIZZLE_TYPE_NULL:
 
478
        pos[6]= 6;
 
479
        break;
 
480
 
 
481
      case DRIZZLE_TYPE_TIMESTAMP:
 
482
        pos[6]= 7;
 
483
        break;
 
484
 
 
485
      case DRIZZLE_TYPE_LONGLONG:
 
486
        pos[6]= 8;
 
487
        break;
 
488
 
 
489
      case DRIZZLE_TYPE_DATETIME:
 
490
        pos[6]= 12;
 
491
        break;
 
492
 
 
493
      case DRIZZLE_TYPE_DATE:
 
494
        pos[6]= 14;
 
495
        break;
 
496
 
 
497
      case DRIZZLE_TYPE_VARCHAR:
 
498
        pos[6]= 15;
 
499
        break;
 
500
 
 
501
      case DRIZZLE_TYPE_DECIMAL:
 
502
        pos[6]= (char)246;
 
503
        break;
 
504
 
 
505
      case DRIZZLE_TYPE_ENUM:
 
506
        pos[6]= (char)247;
 
507
        break;
 
508
 
 
509
      case DRIZZLE_TYPE_BLOB:
 
510
        pos[6]= (char)252;
 
511
        break;
 
512
      }
 
513
    }
 
514
    else
 
515
    {
 
516
      /* Add one to compensate for tinyint removal from enum. */
 
517
      pos[6]= field.type + 1;
 
518
    }
 
519
 
 
520
    int2store(pos+7,field.flags);
 
521
    pos[9]= (char) field.decimals;
 
522
    pos[10]= 0;                // For the future
 
523
    pos[11]= 0;                // For the future
 
524
    pos+= 12;
 
525
 
 
526
    packet.length((uint32_t) (pos - packet.ptr()));
 
527
    if (flush())
 
528
      break;
 
529
  }
 
530
 
 
531
  /*
 
532
    Mark the end of meta-data result set, and store session->server_status,
 
533
    to show that there is no cursor.
 
534
    Send no warning information, as it will be sent at statement end.
 
535
  */
 
536
  writeEOFPacket(session->server_status, session->total_warn_count);
 
537
  return 0;
 
538
 
 
539
err:
 
540
  my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES),
 
541
             MYF(0));
 
542
  return 1;
 
543
}
 
544
 
 
545
bool ClientMySQLProtocol::store(Field *from)
 
546
{
 
547
  if (from->is_null())
 
548
    return store();
 
549
  char buff[MAX_FIELD_WIDTH];
 
550
  String str(buff,sizeof(buff), &my_charset_bin);
 
551
 
 
552
  from->val_str(&str);
 
553
 
 
554
  return netStoreData((const unsigned char *)str.ptr(), str.length());
 
555
}
 
556
 
 
557
bool ClientMySQLProtocol::store(void)
 
558
{
 
559
  char buff[1];
 
560
  buff[0]= (char)251;
 
561
  return packet.append(buff, sizeof(buff), PACKET_BUFFER_EXTRA_ALLOC);
 
562
}
 
563
 
 
564
bool ClientMySQLProtocol::store(int32_t from)
 
565
{
 
566
  char buff[12];
 
567
  return netStoreData((unsigned char*) buff,
 
568
                      (size_t) (internal::int10_to_str(from, buff, -10) - buff));
 
569
}
 
570
 
 
571
bool ClientMySQLProtocol::store(uint32_t from)
 
572
{
 
573
  char buff[11];
 
574
  return netStoreData((unsigned char*) buff,
 
575
                      (size_t) (internal::int10_to_str(from, buff, 10) - buff));
 
576
}
 
577
 
 
578
bool ClientMySQLProtocol::store(int64_t from)
 
579
{
 
580
  char buff[22];
 
581
  return netStoreData((unsigned char*) buff,
 
582
                      (size_t) (internal::int64_t10_to_str(from, buff, -10) - buff));
 
583
}
 
584
 
 
585
bool ClientMySQLProtocol::store(uint64_t from)
 
586
{
 
587
  char buff[21];
 
588
  return netStoreData((unsigned char*) buff,
 
589
                      (size_t) (internal::int64_t10_to_str(from, buff, 10) - buff));
 
590
}
 
591
 
 
592
bool ClientMySQLProtocol::store(double from, uint32_t decimals, String *buffer)
 
593
{
 
594
  buffer->set_real(from, decimals, session->charset());
 
595
  return netStoreData((unsigned char*) buffer->ptr(), buffer->length());
 
596
}
 
597
 
 
598
bool ClientMySQLProtocol::store(const char *from, size_t length)
 
599
{
 
600
  return netStoreData((const unsigned char *)from, length);
 
601
}
 
602
 
 
603
bool ClientMySQLProtocol::wasAborted(void)
 
604
{
 
605
  return net.error && net.vio != 0;
 
606
}
 
607
 
 
608
bool ClientMySQLProtocol::haveMoreData(void)
 
609
{
 
610
  return drizzleclient_net_more_data(&net);
 
611
}
 
612
 
 
613
bool ClientMySQLProtocol::haveError(void)
 
614
{
 
615
  return net.error || net.vio == 0;
 
616
}
 
617
 
 
618
bool ClientMySQLProtocol::checkConnection(void)
 
619
{
 
620
  uint32_t pkt_len= 0;
 
621
  char *end;
 
622
  char scramble[SCRAMBLE_LENGTH];
 
623
 
 
624
  makeScramble(scramble);
 
625
 
 
626
  // TCP/IP connection
 
627
  {
 
628
    char ip[NI_MAXHOST];
 
629
    uint16_t peer_port;
 
630
 
 
631
    if (drizzleclient_net_peer_addr(&net, ip, &peer_port, NI_MAXHOST))
 
632
    {
 
633
      my_error(ER_BAD_HOST_ERROR, MYF(0), session->getSecurityContext().getIp().c_str());
 
634
      return false;
 
635
    }
 
636
 
 
637
    session->getSecurityContext().setIp(ip);
 
638
  }
 
639
  drizzleclient_net_keepalive(&net, true);
 
640
 
 
641
  uint32_t server_capabilites;
 
642
  {
 
643
    /* buff[] needs to big enough to hold the server_version variable */
 
644
    char buff[SERVER_VERSION_LENGTH + SCRAMBLE_LENGTH + 64];
 
645
 
 
646
    server_capabilites= CLIENT_BASIC_FLAGS;
 
647
 
 
648
    if (using_mysql41_protocol)
 
649
      server_capabilites|= CLIENT_PROTOCOL_MYSQL41;
 
650
 
 
651
#ifdef HAVE_COMPRESS
 
652
    server_capabilites|= CLIENT_COMPRESS;
 
653
#endif /* HAVE_COMPRESS */
 
654
 
 
655
    end= buff + strlen(VERSION);
 
656
    if ((end - buff) >= SERVER_VERSION_LENGTH)
 
657
      end= buff + (SERVER_VERSION_LENGTH - 1);
 
658
    memcpy(buff, VERSION, end - buff);
 
659
    *end= 0;
 
660
    end++;
 
661
 
 
662
    int4store((unsigned char*) end, global_thread_id);
 
663
    end+= 4;
 
664
 
 
665
    /* We don't use scramble anymore. */
 
666
    memcpy(end, scramble, SCRAMBLE_LENGTH_323);
 
667
    end+= SCRAMBLE_LENGTH_323;
 
668
    *end++= 0; /* an empty byte for some reason */
 
669
 
 
670
    int2store(end, server_capabilites);
 
671
    /* write server characteristics: up to 16 bytes allowed */
 
672
    end[2]=(char) default_charset_info->number;
 
673
    int2store(end+3, session->server_status);
 
674
    memset(end+5, 0, 13);
 
675
    end+= 18;
 
676
 
 
677
    /* Write scramble tail. */
 
678
    memcpy(end, scramble + SCRAMBLE_LENGTH_323, SCRAMBLE_LENGTH - SCRAMBLE_LENGTH_323);
 
679
    end+= (SCRAMBLE_LENGTH - SCRAMBLE_LENGTH_323);
 
680
    *end++= 0; /* an empty byte for some reason */
 
681
 
 
682
    /* At this point we write connection message and read reply */
 
683
    if (drizzleclient_net_write_command(&net
 
684
          , (unsigned char) PROTOCOL_VERSION
 
685
          , (unsigned char*) ""
 
686
          , 0
 
687
          , (unsigned char*) buff
 
688
          , (size_t) (end-buff)) 
 
689
        ||    (pkt_len= drizzleclient_net_read(&net)) == packet_error 
 
690
        || pkt_len < MIN_HANDSHAKE_SIZE)
 
691
    {
 
692
      my_error(ER_HANDSHAKE_ERROR, MYF(0), session->getSecurityContext().getIp().c_str());
 
693
      return false;
 
694
    }
 
695
  }
 
696
  if (packet.alloc(buffer_length))
 
697
    return false; /* The error is set by alloc(). */
 
698
 
 
699
  client_capabilities= uint2korr(net.read_pos);
 
700
  if (!(client_capabilities & CLIENT_PROTOCOL_MYSQL41))
 
701
  {
 
702
    my_error(ER_HANDSHAKE_ERROR, MYF(0), session->getSecurityContext().getIp().c_str());
 
703
    return false;
 
704
  }
 
705
 
 
706
  client_capabilities|= ((uint32_t) uint2korr(net.read_pos + 2)) << 16;
 
707
  session->max_client_packet_length= uint4korr(net.read_pos + 4);
 
708
  end= (char*) net.read_pos + 32;
 
709
 
 
710
  /*
 
711
    Disable those bits which are not supported by the server.
 
712
    This is a precautionary measure, if the client lies. See Bug#27944.
 
713
  */
 
714
  client_capabilities&= server_capabilites;
 
715
 
 
716
  if (end >= (char*) net.read_pos + pkt_len + 2)
 
717
  {
 
718
    my_error(ER_HANDSHAKE_ERROR, MYF(0), session->getSecurityContext().getIp().c_str());
 
719
    return false;
 
720
  }
 
721
 
 
722
  net.return_status= &session->server_status;
 
723
 
 
724
  char *user= end;
 
725
  char *passwd= strchr(user, '\0')+1;
 
726
  uint32_t user_len= passwd - user - 1;
 
727
  char *l_db= passwd;
 
728
 
 
729
  /*
 
730
    Only support new password format.
 
731
 
 
732
    Cast *passwd to an unsigned char, so that it doesn't extend the sign for
 
733
    *passwd > 127 and become 2**32-127+ after casting to uint.
 
734
  */
 
735
  uint32_t passwd_len;
 
736
  if (client_capabilities & CLIENT_SECURE_CONNECTION &&
 
737
      passwd < (char *) net.read_pos + pkt_len)
 
738
  {
 
739
    passwd_len= (unsigned char)(*passwd++);
 
740
    if (passwd_len > 0)
 
741
    {
 
742
      session->getSecurityContext().setPasswordType(SecurityContext::MYSQL_HASH);
 
743
      session->getSecurityContext().setPasswordContext(scramble, SCRAMBLE_LENGTH);
 
744
    }
 
745
  }
 
746
  else
 
747
    passwd_len= 0;
 
748
 
 
749
  if (client_capabilities & CLIENT_CONNECT_WITH_DB &&
 
750
      passwd < (char *) net.read_pos + pkt_len)
 
751
  {
 
752
    l_db= l_db + passwd_len + 1;
 
753
  }
 
754
  else
 
755
    l_db= NULL;
 
756
 
 
757
  /* strlen() can't be easily deleted without changing client */
 
758
  uint32_t db_len= l_db ? strlen(l_db) : 0;
 
759
 
 
760
  if (passwd + passwd_len + db_len > (char *) net.read_pos + pkt_len)
 
761
  {
 
762
    my_error(ER_HANDSHAKE_ERROR, MYF(0), session->getSecurityContext().getIp().c_str());
 
763
    return false;
 
764
  }
 
765
 
 
766
  /* If username starts and ends in "'", chop them off */
 
767
  if (user_len > 1 && user[0] == '\'' && user[user_len - 1] == '\'')
 
768
  {
 
769
    user[user_len-1]= 0;
 
770
    user++;
 
771
    user_len-= 2;
 
772
  }
 
773
 
 
774
  session->getSecurityContext().setUser(user);
 
775
 
 
776
  return session->checkUser(passwd, passwd_len, l_db);
 
777
}
 
778
 
 
779
bool ClientMySQLProtocol::netStoreData(const unsigned char *from, size_t length)
 
780
{
 
781
  size_t packet_length= packet.length();
 
782
  /*
 
783
     The +9 comes from that strings of length longer than 16M require
 
784
     9 bytes to be stored (see storeLength).
 
785
  */
 
786
  if (packet_length+9+length > packet.alloced_length() &&
 
787
      packet.realloc(packet_length+9+length))
 
788
    return 1;
 
789
  unsigned char *to= storeLength((unsigned char*) packet.ptr()+packet_length, length);
 
790
  memcpy(to,from,length);
 
791
  packet.length((size_t) (to+length-(unsigned char*) packet.ptr()));
 
792
  return 0;
 
793
}
 
794
 
 
795
/**
 
796
  Format EOF packet according to the current client and
 
797
  write it to the network output buffer.
 
798
*/
 
799
 
 
800
void ClientMySQLProtocol::writeEOFPacket(uint32_t server_status,
 
801
                                         uint32_t total_warn_count)
 
802
{
 
803
  unsigned char buff[5];
 
804
  /*
 
805
    Don't send warn count during SP execution, as the warn_list
 
806
    is cleared between substatements, and mysqltest gets confused
 
807
  */
 
808
  uint32_t tmp= min(total_warn_count, (uint32_t)65535);
 
809
  buff[0]= DRIZZLE_PROTOCOL_NO_MORE_DATA;
 
810
  int2store(buff+1, tmp);
 
811
  /*
 
812
    The following test should never be true, but it's better to do it
 
813
    because if 'is_fatal_error' is set the server is not going to execute
 
814
    other queries (see the if test in dispatch_command / COM_QUERY)
 
815
  */
 
816
  if (session->is_fatal_error)
 
817
    server_status&= ~SERVER_MORE_RESULTS_EXISTS;
 
818
  int2store(buff + 3, server_status);
 
819
  drizzleclient_net_write(&net, buff, 5);
 
820
}
 
821
 
 
822
/*
 
823
  Store an integer with simple packing into a output package
 
824
 
 
825
  buffer      Store the packed integer here
 
826
  length    integers to store
 
827
 
 
828
  This is mostly used to store lengths of strings.  We have to cast
 
829
  the result for the LL() becasue of a bug in Forte CC compiler.
 
830
 
 
831
  RETURN
 
832
  Position in 'buffer' after the packed length
 
833
*/
 
834
 
 
835
unsigned char *ClientMySQLProtocol::storeLength(unsigned char *buffer, uint64_t length)
 
836
{
 
837
  if (length < (uint64_t) 251LL)
 
838
  {
 
839
    *buffer=(unsigned char) length;
 
840
    return buffer+1;
 
841
  }
 
842
  /* 251 is reserved for NULL */
 
843
  if (length < (uint64_t) 65536LL)
 
844
  {
 
845
    *buffer++=252;
 
846
    int2store(buffer,(uint32_t) length);
 
847
    return buffer+2;
 
848
  }
 
849
  if (length < (uint64_t) 16777216LL)
 
850
  {
 
851
    *buffer++=253;
 
852
    int3store(buffer,(uint32_t) length);
 
853
    return buffer+3;
 
854
  }
 
855
  *buffer++=254;
 
856
  int8store(buffer,length);
 
857
  return buffer+8;
 
858
}
 
859
 
 
860
void ClientMySQLProtocol::makeScramble(char *scramble)
 
861
{
 
862
  /* This is the MySQL algorithm with minimal changes. */
 
863
  random_seed1= (random_seed1 * 3 + random_seed2) % random_max;
 
864
  random_seed2= (random_seed1 + random_seed2 + 33) % random_max;
 
865
  uint32_t seed= static_cast<uint32_t>((static_cast<double>(random_seed1) / random_max_double) * 0xffffffff);
 
866
 
 
867
  void *pointer= this;
 
868
  uint32_t pointer_seed;
 
869
  memcpy(&pointer_seed, &pointer, 4);
 
870
  uint32_t random1= (seed + pointer_seed) % random_max;
 
871
  uint32_t random2= (seed + global_thread_id + net.vio->sd) % random_max;
 
872
 
 
873
  for (char *end= scramble + SCRAMBLE_LENGTH; scramble != end; scramble++)
 
874
  {
 
875
    random1= (random1 * 3 + random2) % random_max;
 
876
    random2= (random1 + random2 + 33) % random_max;
 
877
    *scramble= static_cast<char>((static_cast<double>(random1) / random_max_double) * 94 + 33);
 
878
  }
 
879
}
 
880
 
 
881
static ListenMySQLProtocol *listen_obj= NULL;
 
882
plugin::Create_function<MySQLPassword> *mysql_password= NULL;
 
883
 
 
884
static int init(drizzled::plugin::Context &context)
 
885
{
 
886
  /* Initialize random seeds for the MySQL algorithm with minimal changes. */
 
887
  time_t seed_time= time(NULL);
 
888
  random_seed1= seed_time % random_max;
 
889
  random_seed2= (seed_time / 2) % random_max;
 
890
 
 
891
  mysql_password= new plugin::Create_function<MySQLPassword>(MySQLPasswordName);
 
892
  context.add(mysql_password);
 
893
 
 
894
  listen_obj= new ListenMySQLProtocol("mysql_protocol", true);
 
895
  context.add(listen_obj); 
 
896
 
 
897
  return 0;
 
898
}
 
899
 
 
900
static DRIZZLE_SYSVAR_UINT(port, port, PLUGIN_VAR_RQCMDARG,
 
901
                           N_("Port number to use for connection or 0 for default to with MySQL "
 
902
                              "protocol."),
 
903
                           NULL, NULL, 3306, 0, 65535, 0);
 
904
static DRIZZLE_SYSVAR_UINT(connect_timeout, connect_timeout,
 
905
                           PLUGIN_VAR_RQCMDARG, N_("Connect Timeout."),
 
906
                           NULL, NULL, 10, 1, 300, 0);
 
907
static DRIZZLE_SYSVAR_UINT(read_timeout, read_timeout, PLUGIN_VAR_RQCMDARG,
 
908
                           N_("Read Timeout."), NULL, NULL, 30, 1, 300, 0);
 
909
static DRIZZLE_SYSVAR_UINT(write_timeout, write_timeout, PLUGIN_VAR_RQCMDARG,
 
910
                           N_("Write Timeout."), NULL, NULL, 60, 1, 300, 0);
 
911
static DRIZZLE_SYSVAR_UINT(retry_count, retry_count, PLUGIN_VAR_RQCMDARG,
 
912
                           N_("Retry Count."), NULL, NULL, 10, 1, 100, 0);
 
913
static DRIZZLE_SYSVAR_UINT(buffer_length, buffer_length, PLUGIN_VAR_RQCMDARG,
 
914
                           N_("Buffer length."), NULL, NULL, 16384, 1024,
 
915
                           1024*1024, 0);
 
916
static DRIZZLE_SYSVAR_STR(bind_address, bind_address, PLUGIN_VAR_READONLY,
 
917
                          N_("Address to bind to."), NULL, NULL, NULL);
 
918
 
 
919
static drizzle_sys_var* sys_variables[]= {
 
920
  DRIZZLE_SYSVAR(port),
 
921
  DRIZZLE_SYSVAR(connect_timeout),
 
922
  DRIZZLE_SYSVAR(read_timeout),
 
923
  DRIZZLE_SYSVAR(write_timeout),
 
924
  DRIZZLE_SYSVAR(retry_count),
 
925
  DRIZZLE_SYSVAR(buffer_length),
 
926
  DRIZZLE_SYSVAR(bind_address),
 
927
  NULL
 
928
};
 
929
 
 
930
DRIZZLE_DECLARE_PLUGIN
 
931
{
 
932
  DRIZZLE_VERSION_ID,
 
933
  "mysql_protocol",
 
934
  "0.1",
 
935
  "Eric Day",
 
936
  "MySQL Protocol Module",
 
937
  PLUGIN_LICENSE_GPL,
 
938
  init,             /* Plugin Init */
 
939
  sys_variables, /* system variables */
 
940
  NULL              /* config options */
 
941
}
 
942
DRIZZLE_DECLARE_PLUGIN_END;